Hook to exception handling / App hangs when _handle_exception is overriden

[mzebrak]

Have you checked closed issues? https://github.com/Textualize/textual/issues?q=is%3Aissue+is%3Aclosed

yes

Please give a brief but clear explanation of the issue. If you can, include a complete working example that demonstrates the bug. Check it can run without modifications.

from textual.app import App
from textual.binding import Binding
from textual.screen import Screen
from textual.widgets import Footer, Header


class CustomException(Exception):
    pass


class SomeScreen(Screen):
    BINDINGS = [
        Binding("f1", "raise_exception", "Raise exception"),
    ]

    def compose(self):
        yield Header()
        yield Footer()

    def action_raise_exception(self) -> None:
        raise CustomException("This is a custom exception")


class Application(App):

    def on_mount(self):
        self.push_screen(SomeScreen())

    def _handle_exception(self, error: Exception) -> None:
        if isinstance(error, CustomException):
            return

        super()._handle_exception(error)


Application().run()

I'm looking for a way to hook into application level exception handling. I found a _handle_exception method, but when I use it, the application hangs right after throwing an exception.

[willmcgugan]

It would be helpful to understand why you want to do this. i.e. what do you want to do in response to your custom exception?

[mzebrak]

This is due to the need to have some global mechanism to detect the exception that is thrown when, let's say, the user is not logged in. Then I would like to show him the login screen so that he would log in and try to perform a certain action again, or preferably this action should be performed right after logging in. Unfortunately, this is due to the problem i described here in which the result from the screen is transferred (via callback).

In my situation callbacks created a big problem because I have several actions that depend on each other, let's say each of them needs to check if the user is logged in (time based authorization via external service, we can't keep it in the state of our application, need to check before every action that requires login). Very quickly the code became unreadable and difficult when you had to put a callback inside a callback. Such a mechanism would allow me to detect an exception when something reported that it should work after logging in and react accordingly e.g. by pushing a login screen on the stack.

[willmcgugan]

Exceptions are not the solution here.

You could define a custom message. Let's call it LoginRequired. When you detect you need to login, post the message with self.post_message(LoginRequired()).

Then you can handle the message in your app as follows:

@on(LoginRequired)
def login_required(self) -> None:
    self.push_screen(LoginScreen())

See also XY Problem

[mzebrak]

Sorry about the XY.

Actually, your solution seems reasonable when the class you want to inform from has access to Textual's App. But the problem is a little more complicated - I can't use the textual messages system since the core, business logic is a separate layer that knows nothing about Textual (think about it like a pure Python implementation). This is because the logic is supposed to be reusable, from the Textual TUI and separate CLI levels.

The first solution that came to mind was "okay, let's just pass the callback to the login handler", instead of just throwing an exception when there is a need to log in. And the result was a deeply nested callbacks structure which I mentioned because push_screen is not a blocking method.

[willmcgugan]

If you have some business logic you could run it in a worker. The callback could set an event or other primitive, which would allow your worker to await the result of the screen.

Feel free to post code on Discord where myself or @davep could offer suggestions.