Multithreading in Trame

[SergeyYakubov]

Hi!

I'm trying to create a Trame App that, on clicking on a "Run" button, executes a long blocking call to a 3rd party library (some computations).

What is the best way to implement it? I tried to use asyncio, but I cannot reload a web page with it (it hangs in that call). I tried to run this long call in a separate thread, but I also want to update the state from that thread to change UI (e.g. to update a label/button text, etc). That does not work - I see no changes in the UI until I reload the page.

[jourdain]

You indeed need a separate thread for the blocking side, then you need to have some monitoring async task to keep the UI to update.
Basically leveraging those 2 entries.

[SergeyYakubov]

Yep, that works, thank you. The code would be simpler if one could just update the state from another thread, but I'm not sure how easy that would be to implement.

[jourdain]

Usually once you start dealing with thread, you most likely want to be in control on when you want to sync things with the client.
Also it is better to be in control rather than being stuck on a too agressive synchronization design that you can not change.

[jourdain]

Also don't forget about that section of the getting started guide.

[Jorge-Monzon-Electroingenium]

Hi!

I am facing a similar problem. I would like to run trame in a second thread but I would like to run trame in a second thread but I can't get it.

Reading your answers I tried to run it with:

coroutine = server.start(exec_mode="coroutine")
taskCreated = create_task(coroutine)

loop = taskCreated.get_loop()

if __name__ == "__main__":
    thread1 = threading.Thread(target=loop)
    thread1.start()

But I didn't get any results, could you please provide some kind of example?

[jourdain]

Please look at threading and asyncio documentation.

[brandonrwin]

For anyone else looking, here's a working example of the "basically leveraging these two lines" reference above, that shows how to do something from different thread. I'm not entirely sure this is exactly correct, since the referenced functions are undocumented, without example, and with unhelpful docstrings.

import queue
import threading
import time

from trame.app import get_server
from trame.ui.vuetify3 import SinglePageLayout
from trame.widgets import html
from trame_server.utils.asynchronous import StateQueue, create_state_queue_monitor_task

server = get_server()
state = server.state
ctrl = server.controller

update_queue = queue.Queue()

fake_state = StateQueue(update_queue)

# Start monitor when server ready
@ctrl.add("on_server_ready")
def start_monitor(**kwargs):
    print("Server ready")
    create_state_queue_monitor_task(server, update_queue)


# Your thread uses fake_state like it's the real state
def worker():
    counter = 0
    while True:
        time.sleep(1)
        counter += 1

        fake_state.counter = counter
        fake_state.message = f"Count: {counter}"

threading.Thread(target=worker, daemon=True).start()

# UI
with SinglePageLayout(server) as layout:
    with layout.content:
        html.H1("{{ message }}")
        html.Div("Counter: {{ counter }}")

if __name__ == "__main__":
    state.counter = 0
    state.message = "Starting..."
    server.start()

Related, the communication in this specific thread is why our team has decided to not go with Trame.

[jourdain]

Here is the test code exercising that piece of code.