How to handle worker exceptions?

[TomJGooding]

Sorry if I'm missing something obvious, but I'm still unclear how to handle worker exceptions even after reading through the Workers guide in the docs.

I've created a simple example below which logs the HTTPX response after submitting a URL. How would you display an error message if HTTPX raises an exception?

Many thanks in advance for any advice!

import httpx
from textual import on, work
from textual.app import App, ComposeResult
from textual.widget import Widget
from textual.widgets import Input, RichLog


class HttpxResponse(Widget):
    def compose(self) -> ComposeResult:
        yield RichLog(highlight=True, auto_scroll=False)

    def update(self, html: str) -> None:
        log = self.query_one(RichLog)
        log.clear()
        log.write(html)

    def load_url(self, url: str) -> None:
        self._load_url(httpx.URL(url))

    @work(
        exclusive=True,
        # exit_on_error=False,
    )
    async def _load_url(self, url: httpx.URL) -> None:
        async with httpx.AsyncClient() as client:
            resp = await client.get(url)
            self.update(resp.text)


class ExampleApp(App):
    CSS = """
    Input {
        dock: top;
    }
    """

    def compose(self) -> ComposeResult:
        yield Input(placeholder="Enter web address")
        yield HttpxResponse()

    @on(Input.Submitted)
    def on_input_submitted(self, event: Input.Submitted) -> None:
        if not event.value:
            return
        html = self.query_one(HttpxResponse)
        try:
            html.load_url(event.value)
        except httpx.HTTPError:
            html.update(f"Oops! Something went wrong loading {event.value}!")


if __name__ == "__main__":
    app = ExampleApp()
    app.run()

[willmcgugan]

When you call a method decorated by @work it will return the Worker object. You can call wait() on that worker object, which will wait for it to finished, and re-raise any exceptions.

However, if you wait for the worker in a message handler you will prevent further messages from being handled. To keep things responsive you can respond to worker events.

That said, it is generally simpler to handle any exceptions within the worker itself. i.e. catch httpx.HTTPError inside _load_url.

[TomJGooding]

Thanks Will for your help with this.

[...] it is generally simpler to handle any exceptions within the worker itself. i.e. catch httpx.HTTPError inside _load_url.

Sorry yes I realise that - I should have clarified my question is how to handle the exceptions outside the worker.

However, if you wait for the worker in a message handler you will prevent further messages from being handled. To keep things responsive you can respond to worker events.

Again sorry if I'm missing something obvious, but how would this work in my example?

I've tried uncommenting the exit_on_error=False and then re-raise the exception, but the app crashes:

    def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
        if event.worker.state == WorkerState.ERROR:
            exception = event.worker.error
            assert exception is not None
            raise exception

[willmcgugan]

You will need to handle the exception in on_worker_state_changed, if you don't want to handle it in _load_url.

You could to it like this:

    async def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
        if event.worker.state == WorkerState.ERROR:
            try:
                await event.worker.wait()
           except httpx.HTTPError:
                ...

[TomJGooding]

Thanks again Will, I've obviously not understood how workers work (no pun intended). It sounds like for my particular example I should drop the worker and instead just use async/await.

[willmcgugan]

It's actually a very appropriate use of workers. The request should be concurrent, or you risk making the UI unresponsive.

But I'm puzzled as to why you want to handle the exception outside of the worker. What's the benefit of that?

[TomJGooding]

Well at least I understood workers to some extent! I agree in most situations it makes sense to handle any exceptions within the worker itself.

But let's say you wanted to create a 'generic' widget for displaying HTML, something like a third party library. The load_url method shouldn't try to handle exceptions any more than Markdown.load does, any errors you instead would want to be handled in the app.