how to hook into large function for display of processbar

[nnako]

Hi,

I was wondering how I would be able to use the ProgressBar widget in order to represent the inner workings of a large function stored within a library.

I thought about this concept:

• create a ProgressBar widget within my GUI
• create an reactive variable to store / update the current progress status
• use the reactive variable within the target library function
• and update the reactive variable within the most outer loop within that library function

here is the example code.

gui.py

#
# imports
#

# non-standard
import textual
from textual import on
from textual.app import App, ComposeResult
from textual.reactive import reactive
from textual.widgets import Header, Footer, Label, Markdown, TabbedContent, TabPane, Static, Button, DataTable, ProgressBar
from rich.text import Text

# application
import test__mllicmgt




#
# application
#

class TestApp(App):




    #
    # construct the object
    #

    def __init__(self, config=None, *args, **kwargs):
        super().__init__(*args, **kwargs)

        # link application
        self.testclass = test__mllicmgt.testclass()
        self.data = None




    #
    # set application hotkeys
    #

    BINDINGS = [
        ("q",  "exit", "Quit"),
    ]




    #
    # reactives
    #

    # reactive status variable to trigger ProgressBar re-render
    progress_status = reactive(0.0)




    #
    # compose the app GUI
    #

    def compose(self) -> ComposeResult:

        # show footer row (and hotkeys)
        yield Footer()

        # show progress bar
        yield ProgressBar()
        yield Button("execute library function", id="btn-exe-lib-fct")




    #
    # watchers for reactives
    #

    def watch_progress_status(self) -> None:
        self.query_one(ProgressBar).update(
            total=1,
            progress=self.progress_status,
        )




    #
    # event handlers and action implementations
    #

    @on(Button.Pressed, "#btn-exe-lib-fct")
    def read_data(self):

        # execute a library function while connecting it with the progress bar
        # widget

        self.data = self.testclass.test(
            _progress_state=self.progress_status,
        )

        # now, when the execute was done, change the button text

        self.query_one(Button).text = "finished"

    def action_exit(self) -> None:
        """exit application"""
        self.exit()




#
# when started from CLI
#

if __name__ == "__main__":

    # start gui
    app = TestApp()
    app.run()

test__mllicmgt.py

import time


#
# test class definition
#

class testclass(object):

    def test(
        self,
        _progress_state=None,       # internal variable to connect to progressbar
        ):


        # iterate over 90 items in order to see floating point increments in
        # the gui's ProgressBar element

        number_of_iterations = 9
        for i in range(number_of_iterations):


            # update progress. this should trigger the re-render in the gui as
            # the _progress_state variable had been defined as "reactive" and
            # is written here.

            if _progress_state is not None:
                _progress_state = i / number_of_iterations


            # wait a second within each iteration in order to imitate a real
            # calculation process

            time.sleep(1)


        # return data
        return [ "some", "data" ]

When Clicking on the Button, the library method gets called, and the reactive variable should get updated. But the ProgressBar in the GUI is not updated. After about 9 seconds, the GUI gets reactive again so that I can exit the application using the <Q> key.

I am sure, I disregarded the whole asyncio subject, and maybe some more...

Are there any tips to get the ProgressBar updated in the GUI while representing the progress of the library method's loop?

Thanks for any help.

[nnako]

in effect, I don't want to create an application from scratch but use textual to equip an already existing application (spread out in multiple libraries) with a graphical user interface. So, the existing application structure is to be kept fix. I am looking for reliable and dynamic ways to "probe" into the functions and react on the inner application's operations.

hope, this would be possible via the concept explained above.