[asking for help] Confliction with periodic multi-thread tasks? Asking for a solution......

[Varisox137]

The situation:
My app now wants to request to my server and get some (up-to-date) chat-messages, so i figured out the following method:

def Support:
    def __init__(self,app):
	self.app=app
	...
	self.executor=concurrent.futures.ThreadPoolExecutor(max_workers=5) # multi-threading
        self._intervals={'keep':1,'msg':2} # time intervals, in seconds
    ......
    def login(self):
    ...
    # after successful login
    self.executor.submit(self.update_connection,self._intervals['keep']) # no bugs currently
    self.executor.submit(self.refresh_messages,self._intervals['msg'])

where Support is a class which instance owned by the App :

class MyApp(toga.App):
    ......
    def startup(self):
    	self.supports=Supports(self)
        ...

The crucial problem now, is that i can find no way of presenting the chat message (successfully obtained from server).

I have tried using Widgets, such as my current (not-working) code:

# in class Support
def refresh_messages(self,interval:int|float):
    while self.alive:
        if self.user:
            ... # gets response from server
            if response['message'].startswith('Successful'):
                public_messages=response['data']['messages']
                if public_messages:
                    self.app.received_messages_multiline.value=public_messages        ######
                    ......
        self.sleep(interval)

related objects:

# in Support
self.alive: bool=True
self.user: str='' # will be non-empty if successfully logged-in

response: {'message':str, 'data':dict}

# in MyApp
self.received_messages_multiline=toga.MultilineTextInput(
    style=Pack(padding=(10,5)), readonly=True, value=''
)

Now, for the marked line above (######), it just wouldn’t work......

however the functionality is just as expected, as soon as i replace that line with print(public_messages)

is it because of the problem with re-assigning string values for Labels/Multi-line?

What might be a possible solution for my wished effects?

Thanks for anyone who have read this whole lot~~

[freakboy3742]

There's no problem changing the value of a MultilineTextInput. The problem is that you can't do this from a thread (at least, not reliably, on all platforms).

Generally speaking, GUI toolkits are sensitive to having GUI operations only performed on the GUI thread. This isn't 100% true on all GUI toolkits, but it's a sufficiently widespread property of GUI toolkits that it's safe to assume it's the default behavior unless you know otherwise. Being a cross-platform toolkit, Toga is effectively constrained by the lowest-common denominator, which means you shouldn't depend on being able to modify your GUI from a non-GUI thread.

There's 2 possible fixes in your case:

1. Do the polling on the background worker thread, and post messages to the GUI thread to apply GUI updates.
2. Do the periodic polling on the GUI thread

In option 1, your worker code remains the same; however, instead of directly changing the value of the MultilineTextWidget, you put a message on a queue with the change you want to make. Then, on the main GUI thread, you install a background worker that periodically wakes up and applies those changes

In option 2, you set up a worker to run as a background task that enters a while True: process; sleep loop.

The magic sauce behind both 1 and 2 is App.add_background_task(). That method installs a hander method on the GUI thread. Toga allows any handler (be that one you're adding to a button handler, or one you're installing a background task) to be a generator:

def my_handler(app, **kwargs):
    while True:
        print("Do stuff")
        yield 1  # release control to the main thread for 1 second

or a co-routine:

async def my_handler(app, **kwargs):
    while True:
        print("Do stuff")
        await asyncio.sleep(1)  # release control to the main thread for 1 second

This generator or co-routine will run on the main GUI thread, but won't block the GUI thread during the "sleep" portion. So - as long as the rest of the logic in the handler is fast, it will happily live as a background worker, ticking every second until the app exits.

However, you can't use time.sleep(), or a standard function handler, because (as you've noted), it's a blocking method that prevents the main GUI event loop from running and updating.

What does "fast" mean? Well, 0.1s max total runtime between sleeps is a reasonable rule of thumb - but the faster the better. This generally means that synchronous API calls to do external network access won't be viable in a handler - but you can use asynchronous network APIs in an async handler. If you use an async httpx or aiohttp client, rather than requests.get(), that won't block the handler while waiting for responses.

[Varisox137]

hello and sorry to disturb again, but i encountered new problems when trying the App.add_background_task method
my code first:

# in class Support
    def refresh_messages(self,interval):
        while self.alive:
        ......
        if response['message'].startswith('Successful'):
                    new_public_messages=response['data']['messages']
                    if new_public_messages:
                        # only saves last 10 '\n\n'
                        all_public_messages=self.app.received_messages_multiline.value+new_public_messages
                        saved='\n\n'.join(all_public_messages.split('\n\n')[-10:]
                        try:
                            self.cache_widget_value_change(
                                widget_name='received_messages_multiline',
                                value=saved
                            )
                        except Exception as e:
                            print(e,e.args)
                        # self.app.received_messages_multiline.value=public_messages
                        self.chat_records[0]+=len(new_public_messages.splitlines())

    # method that helps with background tasks
    def cache_widget_value_change(self,widget_name,value):
        self.app.cache_list.append((widget_name,value))

    def login(self):
	......
        if res['message'].startswith('Successful'): # login complete
            self.app.login_username_input.clear()
            self.user=usr
            self.alive=True
            # starts keeping-alive and receiving messages
            self.executor.submit(self.update_connection,self._intervals['keep'])
            self.executor.submit(self.refresh_messages,self._intervals['msg'])
            self.app.add_background_task(self.app.update_widget_value)
            self.app.enter_scene('cmd_cycle')
        self.app.main_window.info_dialog(
            title='',
            message=res['message']
        )

# in my App class
    async def update_widget_value(self):
        while True:
            if self.cache_list:
                action=self.cache_list.pop(0)
                target_widget=getattr(self,action[0])
                target_value=action[1]
                target_widget.value=target_value
            await asyncio.sleep(1) # testing

and thus when i run briefcase dev and gets in a successful login, it says:

    result = await handler(interface, *args, **kwargs)
                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: Varisox137ServerClient.update_widget_value() takes 1 positional argument but 2 were given

but when i try to use lambda such as
self.app.add_background_task(lambda _: self.app.update_widget_value())
the console this time says

RuntimeWarning: coroutine 'Varisox137ServerClient.update_widget_value' was never awaited
Coroutine created at (most recent call last)
  File "D:\Programming\Python Projects\client-demo\pysvrcli\src\pysvrcli\app.py", line 299, in <lambda>
    on_press=lambda _: self.supports.login()
  File "D:\Programming\Python Projects\client-demo\pysvrcli\src\pysvrcli\app.py", line 184, in login
    self.app.main_window.info_dialog(

really confused......plus up to now i have't understand what a HANDLER really is :-(

[Varisox137]

bytheway, at first i asked GPT and it advised for using an App.maiin_window.interface.call_soon_threadsafe method, which i failed to get the desired results surely. any intel on that approach?

[freakboy3742]

ChatGPT is hallucinating 😀

call_soon_threadsafe is the name of the underlying asyncio API that is ultimately used to schedule the underlying task; but it's not a method that is exposed on Window's interface.

My experience has been that there isn't enough BeeWare code in ChatGPT's training corpus for it to make good predictions at this time. Every Toga/Briefcase example I've seen ChatGPT generate is subtly wrong in some critical way.

[Varisox137]

yep but still......what's the problem with my latest code & what really is a handler ?

[mhsmith]

A handler is one of your functions that Toga calls in response to an event, or in this case in response to you adding a task. In most cases, the handler must take one argument, the object on which the event occurred, which in this case is the App. It should also accept **kwargs in case we add any more arguments in the future.

So you can fix the error by changing this:

async def update_widget_value(self):

to this:

async def update_widget_value(self, app, **kwargs):

Sorry the documentation doesn't make this clear, we'll improve it in the next version.