feat: add abstract app module and refactor config #206

ctrlaltf24 · 2024-10-24T07:44:24Z

Code ready for review, everything should be function, may be a couple lingering bugs, planning to do more testing. Not planning on making any more changes that aren't bug fixes

Improvements

Type Enforcement

Types are checked using a static analysis tool (mypy) to ensure nothing is None when it shouldn't be (or a Path when it should be a string)

Network Caching

All network requests are cached

Tested via:

Installed Logos 10
Deleted the install dir
set a break point in the _net_get function
Installed again
Observed _net_get function wasn't run

Config Enforcement

Wrapper struct to ensure all config variables are set, if not the user is prompted (invalid answers are prompted again).

Additionally configuration hooks were added so all UIs can refresh themselves if the config changes underneath them. A reload function has also been added (TUI only as it's for power users and offers no benefit to the cli)

Config Format Change

In the interest of consistency of variable names, the config keys have changed. Legacy values will continue to be read (and written). New keys take precedence. This new config can be copied to older versions of the installer and it should (mostly) work (not aware of any deficiencies however downgrading is hard to support). Legacy paths are moved to the new location.

Graphical User Interface (tinker)

Ensured that the ask function was never called. We want to use the given UI, as it's prettier. However if the case should arise where we accidentally access a variable before we set it, the user will see a pop-up with the one question. Data flow has been changed to pull all values from the config, it no longer stores copies. It also now populates all drop-downs in real-time as other drop-downs are changed, as a result there was no longer any need for the "Get EXE" and "Get Release List" buttons, so they were removed. Progress bar now considers the entire installation rather than "completing" after each step.

Terminal User Interface (curses)

Appears the same as before from the user's standpoint, however now there is a generic ask page, greatly cutting down on the number of queues/Events. There may be some more unused Queues/Events lingering, didn't see value in cleaning them up.

Command Line Interface

Prompts appears the same as before, progress bar is now prepended to status lines

Closing Notes

One goal of this refactor was to keep the code from being understood by someone who is already familar with it. There is a couple new concepts, the abstract base class, reworked config, and network cache, but the core logic of how it works remains unchanged. If something isn't clear please ask.

Screenshots

GUI Sample

TUI Sample

CLI Sample

GUI behavior

Before Product is selected

After product is selected

Fixes: #147, #234, #35, #168, #155

Works on all three UIs offers a generic function to ask a question that platform independent. If the user fails to offer a response, the installer will terminate. In the GUI this still works, however it may not be desirable to prompt the user for each question. So long as we don't attempt to access the variable before the user has had a chance to put in their preferences it will not prompt them Changed the GUI to gray out the other widgets if the product is not selected. start_ensure_config is called AFTER product is set, if it's called before it attempts to figure out which platform it's on, prompting the user with an additional dialog (not ideal, but acceptable)

thw26 · 2024-10-24T11:21:28Z

ou_dedetai/tui_app.py


    def get_version(self, dialog):
-        self.product_e.wait()
-        question = f"Which version of {config.FLPRODUCT} should the script install?"  # noqa: E501
+        question = f"Which version of {self.conf.faithlife_product} should the script install?"  # noqa: E501


To my knowledge, I need to wait on self.product_e.wait() as if not, the TUI charges through the installer process; should this way now be handled by the TUI's implementation of app._hook_product_update()?

Surprisingly enough it didn't charge through - it waited for the question to be answered before going to the next screen probably because we have two main threads in the TUI:

The input processing thread (main, don't block me)

When events are triggered they're spawned on a new thread (this is the installation thread). Since the ask call is blocking, this gets stopped while the user is inputting their value (which the processing is done on the first thread)

Then if you notice in TUI's ask implementation there is an event wait to communicate between the two threads

thw26 · 2024-10-24T11:31:03Z

Comments on Demonstration

Thanks for this! The framework you have here looks great.

The TUI is a Frankenstein of my own thought, so anything that simplifies it and makes it less bloated is great—I do like seeing lines of code removed.

As mentioned to Nate, I see tui_screen.py as a library that could feasibly be used outside of our project, so also the same with certain aspects of the display code in tui_app.py, say lines 1–350.

LogosLinuxInstaller/ou_dedetai/tui_app.py

Lines 1 to 350 in 0def2e5

    
           import logging 
        
           import os 
        
           import signal 
        
           import threading 
        
           import time 
        
           import curses 
        
           from pathlib import Path 
        
           from queue import Queue 
        
           from . import config 
        
           from . import control 
        
           from . import installer 
        
           from . import logos 
        
           from . import msg 
        
           from . import network 
        
           from . import system 
        
           from . import tui_curses 
        
           from . import tui_screen 
        
           from . import utils 
        
           from . import wine 
        
           console_message = "" 
        
           # TODO: Fix hitting cancel in Dialog Screens; currently crashes program. 
        
           class TUI: 
        
               def __init__(self, stdscr): 
        
                   self.stdscr = stdscr 
        
                   # if config.current_logos_version is not None: 
        
                   self.title = f"Welcome to {config.name_app} {config.LLI_CURRENT_VERSION} ({config.lli_release_channel})"  # noqa: E501 
        
                   self.subtitle = f"Logos Version: {config.current_logos_version} ({config.logos_release_channel})"  # noqa: E501 
        
                   # else: 
        
                   #    self.title = f"Welcome to {config.name_app} ({config.LLI_CURRENT_VERSION})"  # noqa: E501 
        
                   self.console_message = "Starting TUI…" 
        
                   self.llirunning = True 
        
                   self.active_progress = False 
        
                   self.logos = logos.LogosManager(app=self) 
        
                   self.tmp = "" 
        
                   # Queues 
        
                   self.main_thread = threading.Thread() 
        
                   self.get_q = Queue() 
        
                   self.get_e = threading.Event() 
        
                   self.input_q = Queue() 
        
                   self.input_e = threading.Event() 
        
                   self.status_q = Queue() 
        
                   self.status_e = threading.Event() 
        
                   self.progress_q = Queue() 
        
                   self.progress_e = threading.Event() 
        
                   self.todo_q = Queue() 
        
                   self.todo_e = threading.Event() 
        
                   self.screen_q = Queue() 
        
                   self.choice_q = Queue() 
        
                   self.switch_q = Queue() 
        
                   # Install and Options 
        
                   self.product_q = Queue() 
        
                   self.product_e = threading.Event() 
        
                   self.version_q = Queue() 
        
                   self.version_e = threading.Event() 
        
                   self.releases_q = Queue() 
        
                   self.releases_e = threading.Event() 
        
                   self.release_q = Queue() 
        
                   self.release_e = threading.Event() 
        
                   self.manualinstall_q = Queue() 
        
                   self.manualinstall_e = threading.Event() 
        
                   self.installdeps_q = Queue() 
        
                   self.installdeps_e = threading.Event() 
        
                   self.installdir_q = Queue() 
        
                   self.installdir_e = threading.Event() 
        
                   self.wines_q = Queue() 
        
                   self.wine_e = threading.Event() 
        
                   self.tricksbin_q = Queue() 
        
                   self.tricksbin_e = threading.Event() 
        
                   self.deps_q = Queue() 
        
                   self.deps_e = threading.Event() 
        
                   self.finished_q = Queue() 
        
                   self.finished_e = threading.Event() 
        
                   self.config_q = Queue() 
        
                   self.config_e = threading.Event() 
        
                   self.confirm_q = Queue() 
        
                   self.confirm_e = threading.Event() 
        
                   self.password_q = Queue() 
        
                   self.password_e = threading.Event() 
        
                   self.appimage_q = Queue() 
        
                   self.appimage_e = threading.Event() 
        
                   self.install_icu_q = Queue() 
        
                   self.install_icu_e = threading.Event() 
        
                   self.install_logos_q = Queue() 
        
                   self.install_logos_e = threading.Event() 
        
                   # Window and Screen Management 
        
                   self.tui_screens = [] 
        
                   self.menu_options = [] 
        
                   self.window_height = self.window_width = self.console = self.menu_screen = self.active_screen = None 
        
                   self.main_window_ratio = self.main_window_ratio = self.menu_window_ratio = self.main_window_min = None 
        
                   self.menu_window_min = self.main_window_height = self.menu_window_height = self.main_window = None 
        
                   self.menu_window = self.resize_window = None 
        
                   self.set_window_dimensions() 
        
               def set_window_dimensions(self): 
        
                   self.update_tty_dimensions() 
        
                   curses.resizeterm(self.window_height, self.window_width) 
        
                   self.main_window_ratio = 0.25 
        
                   if config.console_log: 
        
                       min_console_height = len(tui_curses.wrap_text(self, config.console_log[-1])) 
        
                   else: 
        
                       min_console_height = 2 
        
                   self.main_window_min = len(tui_curses.wrap_text(self, self.title)) + len( 
        
                       tui_curses.wrap_text(self, self.subtitle)) + min_console_height 
        
                   self.menu_window_ratio = 0.75 
        
                   self.menu_window_min = 3 
        
                   self.main_window_height = max(int(self.window_height * self.main_window_ratio), self.main_window_min) 
        
                   self.menu_window_height = max(self.window_height - self.main_window_height, int(self.window_height * self.menu_window_ratio), self.menu_window_min) 
        
                   config.console_log_lines = max(self.main_window_height - self.main_window_min, 1) 
        
                   config.options_per_page = max(self.window_height - self.main_window_height - 6, 1) 
        
                   self.main_window = curses.newwin(self.main_window_height, curses.COLS, 0, 0) 
        
                   self.menu_window = curses.newwin(self.menu_window_height, curses.COLS, self.main_window_height + 1, 0) 
        
                   resize_lines = tui_curses.wrap_text(self, "Screen too small.") 
        
                   self.resize_window = curses.newwin(len(resize_lines) + 1, curses.COLS, 0, 0) 
        
               @staticmethod 
        
               def set_curses_style(): 
        
                   curses.start_color() 
        
                   curses.use_default_colors() 
        
                   curses.init_color(curses.COLOR_BLUE, 0, 510, 1000) # Logos Blue 
        
                   curses.init_color(curses.COLOR_CYAN, 906, 906, 906) # Logos Gray 
        
                   curses.init_color(curses.COLOR_WHITE, 988, 988, 988) # Logos White 
        
                   curses.init_pair(1, curses.COLOR_BLUE, curses.COLOR_CYAN) 
        
                   curses.init_pair(2, curses.COLOR_BLUE, curses.COLOR_WHITE) 
        
                   curses.init_pair(3, curses.COLOR_CYAN, curses.COLOR_BLUE) 
        
                   curses.init_pair(4, curses.COLOR_WHITE, curses.COLOR_BLUE) 
        
                   curses.init_pair(5, curses.COLOR_BLACK, curses.COLOR_BLUE) 
        
                   curses.init_pair(6, curses.COLOR_BLACK, curses.COLOR_WHITE) 
        
                   curses.init_pair(7, curses.COLOR_WHITE, curses.COLOR_BLACK) 
        
               def set_curses_colors_logos(self): 
        
                   self.stdscr.bkgd(' ', curses.color_pair(3)) 
        
                   self.main_window.bkgd(' ', curses.color_pair(3)) 
        
                   self.menu_window.bkgd(' ', curses.color_pair(3)) 
        
               def set_curses_colors_light(self): 
        
                   self.stdscr.bkgd(' ', curses.color_pair(6)) 
        
                   self.main_window.bkgd(' ', curses.color_pair(6)) 
        
                   self.menu_window.bkgd(' ', curses.color_pair(6)) 
        
               def set_curses_colors_dark(self): 
        
                   self.stdscr.bkgd(' ', curses.color_pair(7)) 
        
                   self.main_window.bkgd(' ', curses.color_pair(7)) 
        
                   self.menu_window.bkgd(' ', curses.color_pair(7)) 
        
               def change_color_scheme(self): 
        
                   if config.curses_colors == "Logos": 
        
                       config.curses_colors = "Light" 
        
                       self.set_curses_colors_light() 
        
                   elif config.curses_colors == "Light": 
        
                       config.curses_colors = "Dark" 
        
                       self.set_curses_colors_dark() 
        
                   else: 
        
                       config.curses_colors = "Logos" 
        
                       config.curses_colors = "Logos" 
        
                       self.set_curses_colors_logos() 
        
               def update_windows(self): 
        
                   if isinstance(self.active_screen, tui_screen.CursesScreen): 
        
                       self.main_window.erase() 
        
                       self.menu_window.erase() 
        
                       self.stdscr.timeout(100) 
        
                       self.console.display() 
        
               def clear(self): 
        
                   self.stdscr.clear() 
        
                   self.main_window.clear() 
        
                   self.menu_window.clear() 
        
                   self.resize_window.clear() 
        
               def refresh(self): 
        
                   self.main_window.noutrefresh() 
        
                   self.menu_window.noutrefresh() 
        
                   self.resize_window.noutrefresh() 
        
                   curses.doupdate() 
        
               def init_curses(self): 
        
                   try: 
        
                       if curses.has_colors(): 
        
                           if config.curses_colors is None or config.curses_colors == "Logos": 
        
                               config.curses_colors = "Logos" 
        
                               self.set_curses_style() 
        
                               self.set_curses_colors_logos() 
        
                           elif config.curses_colors == "Light": 
        
                               config.curses_colors = "Light" 
        
                               self.set_curses_style() 
        
                               self.set_curses_colors_light() 
        
                           elif config.curses_colors == "Dark": 
        
                               config.curses_colors = "Dark" 
        
                               self.set_curses_style() 
        
                               self.set_curses_colors_dark() 
        
                       curses.curs_set(0) 
        
                       curses.noecho() 
        
                       curses.cbreak() 
        
                       self.stdscr.keypad(True) 
        
                       self.console = tui_screen.ConsoleScreen(self, 0, self.status_q, self.status_e, self.title, self.subtitle, 0) 
        
                       self.menu_screen = tui_screen.MenuScreen(self, 0, self.status_q, self.status_e, 
        
                                                                    "Main Menu", self.set_tui_menu_options(dialog=False)) 
        
                       #self.menu_screen = tui_screen.MenuDialog(self, 0, self.status_q, self.status_e, "Main Menu", 
        
                       #                                         self.set_tui_menu_options(dialog=True)) 
        
                       self.refresh() 
        
                   except curses.error as e: 
        
                       logging.error(f"Curses error in init_curses: {e}") 
        
                   except Exception as e: 
        
                       self.end_curses() 
        
                       logging.error(f"An error occurred in init_curses(): {e}") 
        
                       raise 
        
               def end_curses(self): 
        
                   try: 
        
                       self.stdscr.keypad(False) 
        
                       curses.nocbreak() 
        
                       curses.echo() 
        
                   except curses.error as e: 
        
                       logging.error(f"Curses error in end_curses: {e}") 
        
                       raise 
        
                   except Exception as e: 
        
                       logging.error(f"An error occurred in end_curses(): {e}") 
        
                       raise 
        
               def end(self, signal, frame): 
        
                   logging.debug("Exiting…") 
        
                   self.llirunning = False 
        
                   curses.endwin() 
        
               def update_main_window_contents(self): 
        
                   self.clear() 
        
                   self.title = f"Welcome to {config.name_app} {config.LLI_CURRENT_VERSION} ({config.lli_release_channel})"  # noqa: E501 
        
                   self.subtitle = f"Logos Version: {config.current_logos_version} ({config.logos_release_channel})"  # noqa: E501 
        
                   self.console = tui_screen.ConsoleScreen(self, 0, self.status_q, self.status_e, self.title, self.subtitle, 0)  # noqa: E501 
        
                   self.menu_screen.set_options(self.set_tui_menu_options(dialog=False)) 
        
                   # self.menu_screen.set_options(self.set_tui_menu_options(dialog=True)) 
        
                   self.switch_q.put(1) 
        
                   self.refresh() 
        
               # ERR: On a sudden resize, the Curses menu is not properly resized, 
        
               # and we are not currently dynamically passing the menu options based 
        
               # on the current screen, but rather always passing the tui menu options. 
        
               # To replicate, open Terminator, run LLI full screen, then his Ctrl+A. 
        
               # The menu should survive, but the size does not resize to the new screen, 
        
               # even though the resize signal is sent. See tui_curses, line #251 and 
        
               # tui_screen, line #98. 
        
               def resize_curses(self): 
        
                   config.resizing = True 
        
                   curses.endwin() 
        
                   self.update_tty_dimensions() 
        
                   self.set_window_dimensions() 
        
                   self.clear() 
        
                   self.init_curses() 
        
                   self.refresh() 
        
                   msg.status("Window resized.", self) 
        
                   config.resizing = False 
        
               def signal_resize(self, signum, frame): 
        
                   self.resize_curses() 
        
                   self.choice_q.put("resize") 
        
                   if config.use_python_dialog: 
        
                       if isinstance(self.active_screen, tui_screen.TextDialog) and self.active_screen.text == "Screen Too Small": 
        
                           self.choice_q.put("Return to Main Menu") 
        
                   else: 
        
                       if self.active_screen.get_screen_id == 14: 
        
                           self.update_tty_dimensions() 
        
                           if self.window_height > 9: 
        
                               self.switch_q.put(1) 
        
                           elif self.window_width > 34: 
        
                               self.switch_q.put(1) 
        
               def draw_resize_screen(self): 
        
                   self.clear() 
        
                   if self.window_width > 10: 
        
                       margin = config.margin 
        
                   else: 
        
                       margin = 0 
        
                   resize_lines = tui_curses.wrap_text(self, "Screen too small.") 
        
                   self.resize_window = curses.newwin(len(resize_lines) + 1, curses.COLS, 0, 0) 
        
                   for i, line in enumerate(resize_lines): 
        
                       if i < self.window_height: 
        
                           tui_curses.write_line(self, self.resize_window, i, margin, line, self.window_width - config.margin, curses.A_BOLD) 
        
                   self.refresh() 
        
               def display(self): 
        
                   signal.signal(signal.SIGWINCH, self.signal_resize) 
        
                   signal.signal(signal.SIGINT, self.end) 
        
                   msg.initialize_tui_logging() 
        
                   msg.status(self.console_message, self) 
        
                   self.active_screen = self.menu_screen 
        
                   last_time = time.time() 
        
                   self.logos.monitor() 
        
                   while self.llirunning: 
        
                       if self.window_height >= 10 and self.window_width >= 35: 
        
                           config.margin = 2 
        
                           if not config.resizing: 
        
                               self.update_windows() 
        
                               self.active_screen.display() 
        
                               if self.choice_q.qsize() > 0: 
        
                                   self.choice_processor( 
        
                                       self.menu_window, 
        
                                       self.active_screen.get_screen_id(), 
        
                                       self.choice_q.get()) 
        
                               if self.screen_q.qsize() > 0: 
        
                                   self.screen_q.get() 
        
                                   self.switch_q.put(1) 
        
                               if self.switch_q.qsize() > 0: 
        
                                   self.switch_q.get() 
        
                                   self.switch_screen(config.use_python_dialog) 
        
                               if len(self.tui_screens) == 0: 
        
                                   self.active_screen = self.menu_screen 
        
                               else: 
        
                                   self.active_screen = self.tui_screens[-1] 
        
                               if not isinstance(self.active_screen, tui_screen.DialogScreen): 
        
                                   run_monitor, last_time = utils.stopwatch(last_time, 2.5) 
        
                                   if run_monitor: 
        
                                       self.logos.monitor() 
        
                                       self.task_processor(self, task="PID") 
        
                               if isinstance(self.active_screen, tui_screen.CursesScreen): 
        
                                   self.refresh() 
        
                       elif self.window_width >= 10: 
        
                           if self.window_width < 10: 
        
                               config.margin = 1  # Avoid drawing errors on very small screens 
        
                           self.draw_resize_screen() 
        
                       elif self.window_width < 10: 
        
                           config.margin = 0  # Avoid drawing errors on very small screens 
        
               def run(self): 
        
                   try: 
        
                       self.init_curses() 
        
                       self.display() 
        
                   except KeyboardInterrupt: 
        
                       self.end_curses() 
        
                       signal.signal(signal.SIGINT, self.end) 
        
                   finally: 
        
                       self.end_curses() 
        
                       signal.signal(signal.SIGINT, self.end)

(Given the hope of simplifying our queue/event code, many of these lines could be squashed/removed.) The task processor code in tui_app and in gui_app could also be brought into the abstract class. I would also hope that the choice_processor code in tui_app.py might find its way there.

@n8marti has handled the GUI, so I will leave that to him. (Given your review, you might be the third person we've needed: someone who understands both the TUI and the GUI, haha.)

I originally tried to code for the various UIs particularly in msg.py. This eventually got away from me and found its way back in msg.status(). There's likely a fair chunk of room for messaging to be brought into the abstract class given how much code is relatively unused in that module and how msg.status is accounting for each UI. The abstract class lets us do that without all the if/elif.

General Comments

I had also tried this in installer, but the GUI needed enough odds and ends to be separated at the time. Now that we have our working base, I think it'd be great to try to reel in the various odd bits and make these more united, all in the spirit of #147.

As mentioned elsewhere, this would also be helpful for #2 and #87, and for drastically improving code reusability/maintenance. Given your further comments about the suggested config changes, that would go well with #187. While I think all these issues are too much for one PR, I do think we could lump #147 and #187 into this PR's scope as a way of refactoring our code.

Thinking Out Loud

This framework might enable me to further simplify the various calls within tui_app to tui_screen. tui_curses and tui_dialog are fairly static at this point. There are some parts of tui_screen that need to be abstracted, particularly in the console_screen. I've also considered changing the tui_screen class to utilize a method of the tui_app that flags the need for tui_app.refresh to be run again.

n8marti · 2024-11-08T07:02:25Z

Am I understanding correctly that in the GUI the user will see the "Choose which FaithLife product" window first, then they will see the GUI installer window, with all the options pre-populated with defaults? So then they can make adjustments, or just click "Install"?

ctrlaltf24 · 2024-11-08T23:52:28Z

Am I understanding correctly that in the GUI the user will see the "Choose which FaithLife product" window first, then they will see the GUI installer window, with all the options pre-populated with defaults? So then they can make adjustments, or just click "Install"?

Not quite, I liked the current GUI flow so much I didn't want to modify it. Before and after this PR it behaves the same, however if someday in the future there was a code path that tried to retrieve the faithlife product before the prompt showed up, it would open a separate dialog asking that question. In the GUI's case we probably want to avoid this, however the code will handle that case and avoid an error if such a code path were to exist in the future.

n8marti · 2024-11-11T13:58:45Z

Am I understanding correctly that in the GUI the user will see the "Choose which FaithLife product" window first, then they will see the GUI installer window, with all the options pre-populated with defaults? So then they can make adjustments, or just click "Install"?

Not quite, I liked the current GUI flow so much I didn't want to modify it. Before and after this PR it behaves the same, however if someday in the future there was a code path that tried to retrieve the faithlife product before the prompt showed up, it would open a separate dialog asking that question. In the GUI's case we probably want to avoid this, however the code will handle that case and avoid an error if such a code path were to exist in the future.

Okay, I'm happy with that.

n8marti · 2024-11-11T14:05:41Z

If you @ctrlaltf24 can take care of the potential merge conflicts, then I'll look it over again for approval.

…endent-prompts

ctrlaltf24 · 2024-11-12T21:53:41Z

Expanding usage of this framework....

ignore the todos for now

…endent-prompts

and migrate APPDIR_BINDIR and WINESERVER_EXE

ctrlaltf24 · 2024-12-06T20:17:23Z

I think we should decide on a formatting standard and set ourselves up to follow it. We've been vacillating between pep8 and not, and it's making things inconsistent. I don't have a preference, just that we make a decision and stick with it.

I've always liked picking an auto-formatter and just letting it do it's thing rather than trying to have humans being consistent with a styling. How about https://docs.astral.sh/ruff/ ?

Co-authored-by: n8marti

want to initialize logging as early as possible on the offchance reading config fails

ctrlaltf24 · 2024-12-06T20:41:16Z

no more output being written to the log file

fixed

the Installer GUI should still include status and progress, because it's strange to find that sent to the Control Panel instead

See comment #206 (comment)

wine binary options are listed in preferred order, with the newest appimage as the default. This will cause issues.

Fixed, good catch

n8marti · 2024-12-06T20:44:55Z

I like the idea of the Installer window actually just being an Installer _configuration_ window, whose only job is to let the user select non-default config. Then all the statusing and progressing could just happen in the Control Panel window. But in that case I'd suggest a separate button in the CP called "Options" or "Config" somewhere near the "Install" button. It would disappear once the app is installed. That's where my thinking leads to, anyway.

…

On Fri, Dec 6, 2024, 9:12 PM Nathan Shaaban ***@***.***> wrote: ***@***.**** commented on this pull request. ------------------------------ In ou_dedetai/gui.py <#206 (comment)> : > - # Status area. - s1 = Separator(self, orient='horizontal') - self.statusvar = StringVar() - self.status_label = Label(self, textvariable=self.statusvar) - self.progressvar = IntVar() - self.progress = Progressbar(self, variable=self.progressvar) - We have a couple options: - Close the installer window after it started the install (and gray out the install button), showing the progress on the control window. This may be useful if we ever have an "express install button" where the user doesn't select any preferences, it just goes with the default - Make it look how it did before, using a conditional to figure out whether or not to send status messages to the installer window or control window — Reply to this email directly, view it on GitHub <#206 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AFSOCVI7FBNWKRE6GVLMD2D2EIAMPAVCNFSM6AAAAABQQOILYSVHI2DSMVQWIX3LMV43YUDVNRWFEZLROVSXG5CSMV3GSZLXHMZDIOBVG43TMMRUGU> . You are receiving this because you were mentioned.Message ID: ***@***.*** .com>

thw26 · 2024-12-06T21:09:48Z

I like the idea of the Installer window actually just being an Installer configuration window, whose only job is to let the user select non-default config. Then all the statusing and progressing could just happen in the Control Panel window. But in that case I'd suggest a separate button in the CP called "Options" or "Config" somewhere near the "Install" button. It would disappear once the app is installed. That's where my thinking leads to, anyway.

I responded to Nathan's comment above and to make sure it isn't lost between different locations, if we want the GUI to have an install button and a second button, perhaps it should be Install (no options, just defaults) and Advanced Install, but it sounds like six of one and half a dozen of another with your suggestion, Nate.

thw26 · 2024-12-06T21:10:26Z

I think we should decide on a formatting standard and set ourselves up to follow it. We've been vacillating between pep8 and not, and it's making things inconsistent. I don't have a preference, just that we make a decision and stick with it.

I've always liked picking an auto-formatter and just letting it do it's thing rather than trying to have humans being consistent with a styling. How about https://docs.astral.sh/ruff/ ?

I'm all for automation.

and moved faithlife products/versions to a constants

n8marti · 2024-12-07T10:36:46Z

On a good day: 1Mbps down, 500Kbps up On a bad day: 128Kbps down, 64Kbps up Either way, though, we have very high latency. Usually 1-4 seconds for a successful ping to a public IP. In my test yesterday the GUI froze for at least 5, maybe 10 seconds waiting for the network activity to finish.

…

On Fri, Dec 6, 2024, 11:31 PM Nathan Shaaban ***@***.***> wrote: ***@***.**** commented on this pull request. ------------------------------ In ou_dedetai/gui_app.py <#206 (comment)> : > + # FIXME: consider what to do if network is slow, we may want to do this on a + # Separate thread to not hang the UI how slow are we talking for your internet @n8marti <https://github.com/n8marti> ? Doing this on another thread introduces a case (that was completely removed by this refactor) where the install isn't ready immediately. rn if you load this dialog you can hit install at once, no branches, no installs not ready yet, etc. I'm not sure the delay is worth loosing that — Reply to this email directly, view it on GitHub <#206 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AFSOCVPQN24AC4VAMFN7TNL2EIQSHAVCNFSM6AAAAABQQOILYSVHI2DSMVQWIX3LMV43YUDVNRWFEZLROVSXG5CSMV3GSZLXHMZDIOBWGAZDEMRTGE> . You are receiving this because you were mentioned.Message ID: ***@***.*** .com>

ctrlaltf24 · 2024-12-07T10:49:45Z

On a good day: 1Mbps down, 500Kbps up On a bad day: 128Kbps down, 64Kbps up Either way, though, we have very high latency. Usually 1-4 seconds for a successful ping to a public IP. In my test yesterday the GUI froze for at least 5, maybe 10 seconds waiting for the network activity to finish.

Hmm the network cache should make this problem less bad.

I could spawn a thread as soon as the GUI launches that populates all these defaults, so the user wouldn't be aware of the latency. Would that be an acceptable solution?

Trying not to allow the case where the installer window is shown and some values may not be initialized yet - would rather not have the branching

n8marti · 2024-12-07T10:55:10Z

All we're really needing is to get the Logos/Verbum release list, right? Why not show the CP window, but then deactivate the Install button until the network activity is done?

…

On Sat, Dec 7, 2024, 11:50 AM Nathan Shaaban ***@***.***> wrote: On a good day: 1Mbps down, 500Kbps up On a bad day: 128Kbps down, 64Kbps up Either way, though, we have very high latency. Usually 1-4 seconds for a successful ping to a public IP. In my test yesterday the GUI froze for at least 5, maybe 10 seconds waiting for the network activity to finish. Hmm the network cache should make this problem less bad. I could spawn a thread as soon as the GUI launches that populates all these defaults, so the user wouldn't be aware of the latency. Would that be an acceptable solution? Trying not to allow the case where the installer window is shown and some values may not be initialized yet - would rather not have the branching — Reply to this email directly, view it on GitHub <#206 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AFSOCVJY4HMAAJAOZY3VRHT2ELHF7AVCNFSM6AAAAABQQOILYSVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZDKMRVGA3DSMZUHA> . You are receiving this because you were mentioned.Message ID: ***@***.***>

ctrlaltf24 · 2024-12-07T11:07:08Z

All we're really needing is to get the Logos/Verbum release list, right? Why not show the CP window, but then deactivate the Install button until the network activity is done?

My hesitation is I'd rather not end up with a case where the user gets App.ask'ed a question. If faithlife_produce_version isn't set early, it will be easier to accidentally introduce code paths that would individually prompt the user for this value. That would happen if anywhere in the app the faithlife_produce_version is accessed before it's set.

By blocking we're assured by the time the UI displays this value is set. Otherwise if it's not blocked we'd have to think about the case where it isn't set yet in at least part of the GUI.

n8marti · 2024-12-07T17:16:07Z

It's a nice improvement in the GUI with the [Install] [Advanced install] options. Not sure about the look of it, but I don' t have any better ideas at this point.

I just did a completely clean test run: no config, no network cache file, no existing LogosBible10 folder. It failed with this result:
oudedetai_clean-failed.log

[...]
2024-12-07 17:50:59 DEBUG: wine_binary_options=['/home/nate/Téléchargements/wine-devel_9.19-x86_64.AppImage', '/home/nate/Téléchargements/wine-staging_8.14-x86_64.AppImage', '/home/nate/Téléchargements/wine-devel_8.19-x86_64.AppImage', '/home/nate/Téléchargements/wine-devel_9.12-x86_64.AppImage', '/home/nate/LogosBible10/data/bin/wine-devel_9.19-x86_64.AppImage']
2024-12-07 17:50:59 INFO: Writing config to /home/nate/.config/FaithLife-Community/oudedetai.json
2024-12-07 17:50:59 DEBUG: Installing…: None
2024-12-07 17:50:59 DEBUG: Install 7: Asking questions if needed…
2024-12-07 17:50:59 DEBUG: LLI self-update check: output=<VersionComparison.DEVELOPMENT: 3>
2024-12-07 17:50:59 DEBUG: > app.conf.faithlife_product='Logos'
2024-12-07 17:50:59 DEBUG: > app.conf.faithlife_product_version='10'
2024-12-07 17:50:59 DEBUG: > app.conf.faithlife_product_release='38.0.0.0578'
2024-12-07 17:50:59 DEBUG: > app.conf.install_dir='/home/nate/LogosBible10'
2024-12-07 17:50:59 DEBUG: > app.conf.installer_binary_dir='/home/nate/LogosBible10/data/bin'
2024-12-07 17:50:59 DEBUG: > app.conf.wine_appimage_path=PosixPath('/home/nate/Téléchargements/wine-devel_9.19-x86_64.AppImage')
2024-12-07 17:50:59 DEBUG: > app.conf.wine_appimage_recommended_url='https://github.com/FaithLife-Community/wine-appimages/releases/download/9.19-devel/wine-devel_9.19-x86_64.AppImage'
2024-12-07 17:50:59 DEBUG: > app.conf.wine_appimage_recommended_file_name='wine-devel_9.19-x86_64.AppImage'
[...]
2024-12-07 17:51:08 DEBUG: subprocess cmd: '/home/nate/Téléchargements/wine64 wineboot --init'
2024-12-07 17:51:08 ERROR: An unexpected error occurred when running ['/home/nate/Téléchargements/wine64', 'wineboot', '--init']: [Errno 2] No such file or directory: '/home/nate/Téléchargements/wine64'

And here's the Exception thrown in the terminal:

Exception in thread Ou Dedetai <function ControlWindow.run_install.<locals>._install at 0x7f51e0a66e80>:
Traceback (most recent call last):
  File "/usr/lib/python3.12/threading.py", line 1073, in _bootstrap_inner
    self.run()
  File "/usr/lib/python3.12/threading.py", line 1010, in run
    self._target(*self._args, **self._kwargs)
  File "/home/nate/g/LogosLinuxInstaller-refactor/ou_dedetai/gui_app.py", line 462, in _install
    installer.install(self)
  File "/home/nate/g/LogosLinuxInstaller-refactor/ou_dedetai/installer.py", line 344, in install
    ensure_launcher_shortcuts(app)
  File "/home/nate/g/LogosLinuxInstaller-refactor/ou_dedetai/installer.py", line 328, in ensure_launcher_shortcuts
    ensure_launcher_executable(app=app)
  File "/home/nate/g/LogosLinuxInstaller-refactor/ou_dedetai/installer.py", line 306, in ensure_launcher_executable
    ensure_config_file(app=app)
  File "/home/nate/g/LogosLinuxInstaller-refactor/ou_dedetai/installer.py", line 297, in ensure_config_file
    ensure_product_installed(app=app)
  File "/home/nate/g/LogosLinuxInstaller-refactor/ou_dedetai/installer.py", line 279, in ensure_product_installed
    ensure_icu_data_files(app=app)
  File "/home/nate/g/LogosLinuxInstaller-refactor/ou_dedetai/installer.py", line 267, in ensure_icu_data_files
    ensure_winetricks_applied(app=app)
  File "/home/nate/g/LogosLinuxInstaller-refactor/ou_dedetai/installer.py", line 214, in ensure_winetricks_applied
    ensure_wineprefix_init(app=app)
  File "/home/nate/g/LogosLinuxInstaller-refactor/ou_dedetai/installer.py", line 205, in ensure_wineprefix_init
    system.wait_pid(process)
  File "/home/nate/g/LogosLinuxInstaller-refactor/ou_dedetai/system.py", line 910, in wait_pid
    os.waitpid(-process.pid, 0)
                ^^^^^^^^^^^
AttributeError: 'NoneType' object has no attribute 'pid'

I'm not sure which is the cause and which are symptoms, but it seems the "auto-config" set the wine binary as the appimage in my Downloads folder (rather than one to be copied into LogosBible10), the appimage was never copied into LogosBible10, but the symlinks were still created in LogosBible10 as if the appimage were there, but then the installer looked for the symlinks in the Downloads folder, which were not there:

$ ll ~/Téléchargements | grep wine
-rw-rw-r--  1 nate nate  595593666 Apr  7  2024 wine64_bottle.tar.gz
drwxr-xr-x  5 nate nate       4096 Dec  6 15:54 wine_9.19/
-rw-rw-r--  1 nate nate   68563244 Dec  6 16:09 wine_9.19+20.04.tar.xz
-rwxr-xr-x  1 nate nate 1138655920 Jul  6 19:43 wine-devel_8.19-x86_64.AppImage*
-rwxrw-r--  1 nate nate  211538264 Dec  6 09:21 wine-devel_9.12-x86_64.AppImage*
-rwxr-xr-x  1 nate nate  211538264 Oct  8 17:53 wine-devel_9.19-x86_64.AppImage*
-rwxrwxr-x  1 nate nate  209846616 Jun 29 05:57 wine-stable_9.0-x86_64.AppImage*
-rwxr-xr-x  1 nate nate  923726168 Aug 30  2023 wine-staging_8.14-x86_64.AppImage*
-rw-rw-r--  1 nate nate     689866 Sep 16 10:48 winetricks-20240105.zip
$ ll LogosBible10/data/bin/
total 892
drwxrwxr-x 2 nate nate   4096 Dec  7 17:51 ./
drwxrwxr-x 4 nate nate   4096 Dec  7 17:51 ../
lrwxrwxrwx 1 nate nate     33 Dec  7 17:51 selected_wine.AppImage -> ./wine-devel_9.19-x86_64.AppImage
lrwxrwxrwx 1 nate nate     24 Dec  7 17:51 wine -> ./selected_wine.AppImage
lrwxrwxrwx 1 nate nate     24 Dec  7 17:51 wine64 -> ./selected_wine.AppImage
lrwxrwxrwx 1 nate nate     24 Dec  7 17:51 wineserver -> ./selected_wine.AppImage
-rwxr-xr-x 1 nate nate 904682 Dec  7 17:51 winetricks*

n8marti · 2024-12-07T17:18:47Z

Another issue we need to figure out is orphaned mounted appimages. I was suspicious, and I found dozens of them in /tmp. I removed them all before the clean install, and afterwards there were 4 new ones there:

$ mount | grep wine  
wine-devel_9.19-x86_64.AppImage on /tmp/.mount_wine64mfgdHl type fuse.wine-devel_9.19-x86_64.AppImage (ro,nosuid,nodev,relatime,user_id=1000,group_id=1001)  
wine-devel_9.19-x86_64.AppImage on /tmp/.mount_wine64cJaMiA type fuse.wine-devel_9.19-x86_64.AppImage (ro,nosuid,nodev,relatime,user_id=1000,group_id=1001)  
wine-devel_9.19-x86_64.AppImage on /tmp/.mount_winesecEKcFO type fuse.wine-devel_9.19-x86_64.AppImage (ro,nosuid,nodev,relatime,user_id=1000,group_id=1001)  
wine-devel_9.19-x86_64.AppImage on /tmp/.mount_wine-dJOcobb type fuse.wine-devel_9.19-x86_64.AppImage (ro,nosuid,nodev,relatime,user_id=1000,group_id=1001)

This could very well pre-date the refactor, but it still needs to be sorted out. I'll more into it tonight if I have time.

n8marti · 2024-12-07T17:20:18Z

One minor change: There's a typo in this status message: "Setting Font Smooting to RGB..." should say "Smoothing"

Also properly parse legacy ENVs as bools Also dump other configs

in the case .vscode is a symlink

ctrlaltf24 · 2024-12-10T01:19:30Z

It's a nice improvement in the GUI with the [Install] [Advanced install] options. Not sure about the look of it, but I don' t have any better ideas at this point.

I just did a completely clean test run: no config, no network cache file, no existing LogosBible10 folder. It failed with this result: oudedetai_clean-failed.log

Should be fixed, try again

This could very well pre-date the refactor, but it still needs to be sorted out. I'll more into it tonight if I have time.

likely independent, not addressing in this PR

recently added a full config hook in installer.install, these separate ones are no longer needed

gray out install buttons until faithlife product versions downloads (so we know which one to install)

- de-couple wine_binary_files from faithlife_product_version - populate product release immediately if possible

ctrlaltf24 force-pushed the feat-platform-independent-prompts branch from 8042817 to 82d0c94 Compare October 24, 2024 07:45

thw26 reviewed Oct 24, 2024

View reviewed changes

n8marti self-requested a review November 11, 2024 13:59

Merge remote-tracking branch 'upstream/main' into feat-platform-indep…

a3bfa78

…endent-prompts

ctrlaltf24 marked this pull request as draft November 12, 2024 21:53

ctrlaltf24 added 4 commits November 12, 2024 14:29

refactor: move constants to their own file

60860f8

refactor: move function from config to utils

a3244a7

feat(wip): move the install prompts into the abstract class

4676033

ignore the todos for now

refactor: function never called with an argument

923cbbc

thw26 mentioned this pull request Nov 13, 2024

Switch TUI to urwid #228

Open

ctrlaltf24 added 13 commits November 12, 2024 21:43

fix(wip): add prompting and started new storage implementation

c97b5f5

feat(wip): more progress

a2001e8

Merge remote-tracking branch 'upstream/main' into feat-platform-indep…

e27d248

…endent-prompts

feat: load legacy envs into new framework

630bbcf

and migrate APPDIR_BINDIR and WINESERVER_EXE

fix: migrate CUSTOMBINPATH

c68e29f

fix: migrate LOGOS_VERSION

43d7644

fix: migrate LOGOS_EXECUTABLE

49a3c8c

fix: remove unused LOGOS64_MSI

3246bc5

fix: migrate LOGOS64_URL

d930d47

fix: migrate WINEDLLOVERRIDES

197609c

fix: migrate SKIP_WINETRICKS

4b76466

fix: remove unused REINSTALL_DEPENDENCIES

65e5369

fix: migrate WINEDEBUG, VERBOSE, DEBUG and LOG_LEVEL

ac5308b

ctrlaltf24 added 3 commits December 6, 2024 12:22

fix: handle single appimage duplicate rather than reordering

becb67e

docs: update comment as to why launcher shortcuts are skipped

d6bd941

Co-authored-by: n8marti

fix: restore app logging

59ace4f

want to initialize logging as early as possible on the offchance reading config fails

ctrlaltf24 added 4 commits December 6, 2024 15:27

fix: logging

7fc7515

chore: more descriptive message when file config not found

671d563

chore: remove unused code

6dd127b

feat: add a install button that doesn't prompt in GUI

4819bb4

and moved faithlife products/versions to a constants

ctrlaltf24 requested a review from n8marti December 7, 2024 00:14

ctrlaltf24 added 5 commits December 9, 2024 16:48

fix: support env overriding

8a9a52e

Also properly parse legacy ENVs as bools Also dump other configs

chore: fix spelling

99d7243

fix: optional pid

9d3b99a

fix: ensure wine_appimage_path is in appbin dir

632e98b

chore: ignore .vscode files as well

da85163

in the case .vscode is a symlink

ctrlaltf24 added 4 commits December 9, 2024 17:21

refactor: move post-install hooks

baed48c

recently added a full config hook in installer.install, these separate ones are no longer needed

fix: handle slow network case

eb11a91

gray out install buttons until faithlife product versions downloads (so we know which one to install)

fix: enable install button after release download is complete

31571b8

- de-couple wine_binary_files from faithlife_product_version - populate product release immediately if possible

fix: normalize appimage path into install_dir

7ab46cd

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

feat: add abstract app module and refactor config #206

feat: add abstract app module and refactor config #206

ctrlaltf24 commented Oct 24, 2024 •

edited

Loading

thw26 Oct 24, 2024

ctrlaltf24 Oct 24, 2024

thw26 commented Oct 24, 2024 •

edited

Loading

n8marti commented Nov 8, 2024

ctrlaltf24 commented Nov 8, 2024

n8marti commented Nov 11, 2024

n8marti commented Nov 11, 2024

ctrlaltf24 commented Nov 12, 2024

ctrlaltf24 commented Dec 6, 2024

ctrlaltf24 commented Dec 6, 2024 •

edited

Loading

n8marti commented Dec 6, 2024 via email

thw26 commented Dec 6, 2024

thw26 commented Dec 6, 2024

n8marti commented Dec 7, 2024 via email

ctrlaltf24 commented Dec 7, 2024

n8marti commented Dec 7, 2024 via email

ctrlaltf24 commented Dec 7, 2024

n8marti commented Dec 7, 2024

n8marti commented Dec 7, 2024

n8marti commented Dec 7, 2024

ctrlaltf24 commented Dec 10, 2024

feat: add abstract app module and refactor config #206

Are you sure you want to change the base?

feat: add abstract app module and refactor config #206

Conversation

ctrlaltf24 commented Oct 24, 2024 • edited Loading

Improvements

Type Enforcement

Network Caching

Config Enforcement

Config Format Change

Graphical User Interface (tinker)

Terminal User Interface (curses)

Command Line Interface

Closing Notes

Screenshots

GUI Sample

TUI Sample

CLI Sample

GUI behavior

thw26 Oct 24, 2024

Choose a reason for hiding this comment

ctrlaltf24 Oct 24, 2024

Choose a reason for hiding this comment

thw26 commented Oct 24, 2024 • edited Loading

Comments on Demonstration

General Comments

Thinking Out Loud

n8marti commented Nov 8, 2024

ctrlaltf24 commented Nov 8, 2024

n8marti commented Nov 11, 2024

n8marti commented Nov 11, 2024

ctrlaltf24 commented Nov 12, 2024

ctrlaltf24 commented Dec 6, 2024

ctrlaltf24 commented Dec 6, 2024 • edited Loading

n8marti commented Dec 6, 2024 via email

thw26 commented Dec 6, 2024

thw26 commented Dec 6, 2024

n8marti commented Dec 7, 2024 via email

ctrlaltf24 commented Dec 7, 2024

n8marti commented Dec 7, 2024 via email

ctrlaltf24 commented Dec 7, 2024

n8marti commented Dec 7, 2024

n8marti commented Dec 7, 2024

n8marti commented Dec 7, 2024

ctrlaltf24 commented Dec 10, 2024

ctrlaltf24 commented Oct 24, 2024 •

edited

Loading

thw26 commented Oct 24, 2024 •

edited

Loading

ctrlaltf24 commented Dec 6, 2024 •

edited

Loading