Select widget "disabled"

[kce0002]

Some background:
I am trying to disable the Select widget at runtime, and then re-enable it when a function is complete. I am capturing the event of the Select being changed and I don't want that event to fire while this function is executing. When I create the Select in my on_mount method, I give the widget an ID so I can reference it later. This is also the only Select widget in this application.

Here is the issue:
It seems like both query_one and get_widget_by_id are blocking when trying to find my Select widget. I am trying both of these methods and I get the same result (application essentially stalled):

self.get_widget_by_id("my_select").disabled = True
# OR
self.query_one(Select).disabled = True

It should also be noted that I am creating the select with the following call (perhaps this is the issue):

Select.from_values(my_values, id="my_select", classes="myclass")

Other info:
Using either of these methods works with other widgets, just not my case for Select.

[kce0002]

I should also mention I am using python 3.9.14 on RHEL 9.1 and textual 0.47.1

[davep]

Do you think you could provide an MRE of the exact situation? For example, with this code:

from textual import on
from textual.app import App, ComposeResult
from textual.widgets import Button, Select

class DisableSelectApp(App[None]):

    def compose(self) -> ComposeResult:
        yield Button("Disable", id="disable")
        yield Button("Enable", id="enable")
        yield Select[int]((f"This is selection {n}", n) for n in range(20))

    @on(Button.Pressed)
    def set_select_disabled(self, event: Button.Pressed) -> None:
        self.query_one(Select).disabled = event.button.id == "disable"

if __name__ == "__main__":
    DisableSelectApp().run()

I can disable and enable the Select just fine.

[kce0002]

Sure thing. I will write one up now. Thanks for getting back so quickly! Also, my apologies for originally opening this in the wrong place.

[davep]

No apology needed; wasn't really the wrong place as such, and could of course end up being an issue if we identify a problem. :-)

[kce0002]

Yours worked properly on my machine.

Here is the MRE:

#!/usr/bin/env python3
import threading
import time
from textual import on
from textual.app import App, ComposeResult
from textual.widgets import Button, Select

class DisableSelectApp(App[None]):

    def compose(self) -> ComposeResult:
        yield Button("Start Process", id="start")
        yield Select.from_values([str(i) for i in range(5)], id="my_select")

    def on_mount(self) -> None:
        self.process_running = False
        threading.Thread(target=self.background_thread, daemon=True).start()

    def background_thread(self):
        while True:
            if self.process_running:
                self.get_widget_by_id("my_select").disabled = True
                time.sleep(5)
                self.process_running = False
                self.get_widget_by_id("my_select").disabled = False
            time.sleep(1)

    @on(Button.Pressed)
    def start_process(self, event: Button.Pressed) -> None:
        self.process_running = True

if __name__ == "__main__":
    DisableSelectApp().run()

Note: if I change to disable/enable the button instead of the select, it performs as expected.

[kce0002]

Also, it seems like the select widget actually gets disabled, but it never executes beyond that line

[davep]

So the issue here is you're trying to interact with the Textual DOM from a thread, and doing things that block, etc.

To start with you may want to have a read of the guide to workers.

[kce0002]

I see. This project is a port of legacy code so threading was used to not freeze up the UI in the older application. It still seems odd that it would work with other types of widgets. I may have missed it in the docs, but is there a warning that you will get unexpected behavior if you use the python threading library to interact with the DOM?

[davep]

I can't personally recall if it's mentioned elsewhere in the docs; but the final note in the guide I link to above does talk about how to interact with the DOM from a threaded worker.

[kce0002]

Understandable, got to love porting legacy code. LOL! Thanks for the help.

[kce0002]

I have come up with a solution using the threaded workers for my case. However, I would like to mention there is still an issue with interacting with the DOM using the threaded worker. Specifically, the following code has an issue if run from a threaded worker:

self.query_one(Select).disabled = True # Or False

My solution was to wrap this in a function:

def change_select_disabled(self, widget_id: str, disabled: bool) -> None:
    self.get_widget_by_id(widget_id).disabled = disabled

Then where I need to change the select state in the threaded worker:

self.call_from_thread(self.change_select_disabled, widget_id, True) # Or False

I am sure there's a more elegant solution to this, perhaps using a lambda expression. However, I would think the widget classes should include a "setter" type method so the user of the library doesn't have to write their own.

Again, thanks for the help and I think this should be considered closed.