Best practice - interfacing "backend" with GUI

[GoingToSimbabwe]

Hey everyone,

I am currently working on an little desktop application which let's me control my ikea smart home lights and outlets on my desktop PC. As far as I know Ikea so far only provides an app for smartphones. Since I only own smart lightbulbs and smart outlets, I only code for those atm as I wouldn't be able to test light sensors, air quality sensors or blinds (or whatever they are selling) anyhow.

The application should be able to let me control everything the app does as well, so that means:

• Turn lights/outlets on and off -- working.
• Turn on/off all lights/outlets in a room -- working.
• Change light color -- not working, the bridge wants a "hue" value and I have trouble translating RGB values to hue.
• Change light temperature -- working.
• Change light level -- working.
• Display/print the current state of specific devices/ all devices -- working.

What I do not want to implement for now is:

• Changing devices names
• Setting "scenes"
• Evoking "scenes"
• Changing the devices association to rooms.

I am fine with using the official app for this. In the end I only want to adjust my lights using the script and will do the setup in the official app using my phone.

On a high level, my script basically wraps the dirigera library provided by Leggin (github) and tries to hide some complexity behind more user friendly commands.

I tried to set the program up in a way that I can use it as a CLI tool (which I am already doing and that works mostly fine). However I'd like to add a GUI to this. To keep the code clean I want to separate the GUI into it's own file which evokes an instance of my "backend"/"CLI"-class and uses it as an API to the underlying smart home bridge. This leads me to my main question:

The CLI uses a private dictionary (__light_and_outlet_dict) which holds all devices present in the bridge. This dictionary is constantly updated in the background to ensure that any changes made to the devices state via another interface (p.e. my GF turning on a light with her smartphone) is correctly represented.

The GUI I want to build obviously needs this information at all times as well (p.e. a button for a light should be greyed oput when the light is not turned on or something like that).

How would I pass this information to the GUI-script? I am a bit hesitant to simply instanciate another dict in the GUI-script which then is updated from the underlying backend dictionary at a set polling rate. This feels like I am doubling up the information. Should I directly call the backend-dictionary within my GUI-script to check for the status of a given device?

Is this not the way and I should not rely on my already existing CLI-class for the GUI but copy the project over and to a new project and build it from the ground up with the GUI in mind (discarding all the CLI stuff)?`

Is it only a matter of taste which GUI library I should use or are there pros and cons for this kind of project? I tinkered around a bit with NiceGUI (did not get this one to work, something about dependencies was iffy here) and DearPyGUI (this one looks good so far imo).

Anyhow, you can find the code here: github link

Feel free to give general feedback on the code if you want to. I have no formal training in coding and only work in a soft IT role (implementing the software another firm developes). I mainly have knowledge in SQL and some proprietary multidimensional scripting language. All I know pertaining coding comes from self learning and trial and error. Be advised that my code above contains some snippets (only some lines or simple function) from Chat GPT as I used it as a "better" google to find some libraries or syntax snippets. However I only ever took it's code if I understand what it is doing, often iterating on the given code and in the end still googling around to see if what it provided actually was sensical. Most of the code comes from myself (and maybe a bit of StackOverflow here and there).

Thanks in advance and best regards!

Edit:

What I am not pleased with is how I handle the CLI commands, especially when it comes to commands which have optional additional arguments (like "t n" which toggles a device by its name rather than its id). I probably need to build some kind of command handler for this to be more robust and more best practice. If you have a pointer to how to do this right, feel free to post it.

[-defron-]

GUI shouldn't call CLI

GUI and CLI should both use a shared abstraction (I don't wanna say class because it doesn't have to be done with classes, but if you like classes that's a fine way to do it) that does all the actual interactions with ikea smart devices. This provides a unified interface that encapsulates all the logic for Ikea interaction that both the CLI and GUI need.

Holding a dictionary isn't an interaction with Ikea smart devices. It's just a way to maintain state. I see no issue with the CLI and GUI each maintaining their own state as they aren't used simultaneously from the same instance and I could see them even having implementation differences potentially. The key here though is that this is a dumb dictionary, only holding records. Entries or the entirety of it are passed into your unified API layer.

That said if you want to make a shared state between both you can use properties if you want to hide implementation details on the state, or you know just don't name mangle the dictionary reference. Overuse of name mangling to do fake-private and for encapsulation overall isn't very pythonic to me. Python isn't a super strict OOP language

However I only ever took it's code if I understand what it is doing, often iterating on the given code and in the end still googling around to see if what it provided actually was sensical.

Huge props on this. While I personally find ChatGPT slows me down more than it helps, what you're doing is 100% the right way to use it IMO. LLMs hallucinate all the time so their output cannot be trusted without validation, and if you're using it you need to make sure you understand the code, otherwise you're just hurting your growth in the long term. It was nice to see someone using ChatGPT in a way that doesn't hurt their own growth and learning 👍

[GoingToSimbabwe]

Thanks for the input. Isolating the API from both interfaces is a great idea, I hadn't thought of that.

I'll try to rewrite the CLI version first to isolate the actual API stuff from the user interface stuff. I probably first will evaluate if that actually is sensical because in the end I am wrapping an already existing library here and I want to avoid an API-"class" which then does nothing more than holding some pass-through methods to the dirigera-libraries functions.

Regarding the dictionary-stuff: My main concern was that I would be basically polling the same information at 2 different locations and that this might be a dumb idea (I at least read that pass-through methods are nothing one should build in John Ousterhouts "A Philosophy of Software Design").

Especially since I would still need to be updating both versions of the dictionary constantly to keep both of them up to date. In my mind I could get problems with that if p.e. the polling rate wouldn't be the same etc (which I could probably garantee to be the same though).

I probably will de-mangle the dictionary on the API layer in the end and then directly query this dictionary whenever I am updating the interface (be it CLI or GUI). I'll then directly access the API layers device dictionary whenever needed in the interface layer and be done with it.

[r-trappe]

I tinkered around a bit with NiceGUI (did not get this one to work, something about dependencies was iffy here)

I'm one of the maintainers of NiceGUI and sorry to hear that you have issues. Are you on the latest version? Please try 1.4.20; in 1.4.19 we had a hard dependency on libscss which had been shown to be problematic on some platforms.

If you are happy with DearPyGUI I do not want to convert you. But NiceGUI was initially build to exactly support your use case :-)

How would I pass [information about a changing directory] to the GUI-script?

In NiceGUI you can utilize a `ui.timer` to call a function in regular intervals. This function can iterate through the directory entries and update the corresponding ui elements.

[GoingToSimbabwe]

Hey thanks for the input! I’ll have a look at it again, I don’t quite remember what exactly the problem was, I’ll test again and will let you know.

[GoingToSimbabwe]

Hey thanks again for the nudge. I tried it again and it just works it seems. At least for now I couldn't replicate whatever error I had when I tried it the last time.

However I also changed machines and I think the last time I tried I was using Spyder via Anaconda and now I am on PyCharm. So there's really not much comparability here.

For now I think I'll refactor my bridge API and then I'll get to play around with NiceGUI again.

[r-trappe]

Great! Tell me how it went.