[Question]Flet 0.80.5 (Win10/Async Mode): Can't catch on_click exceptions (page.on_error/asyncio handler failed)

[hmill]

Question

Hi all,

I'm developing an async desktop application with Flet 0.80.5 on Windows 10 (Python 3.13.1), and I'm stuck on handling exceptions triggered in the on_click event of Flet controls (e.g. ElevatedButton, TextButton).

Current Problem

When an unhandled exception occurs inside the async on_click callback function, the app directly pops up an exception traceback window. The only way to continue using the app is to close it and restart it, and the UI can't stay in its original state – this creates a very poor user experience.

What I've Tried (But All Failed)

1. Registered a global error handler with page.on_error – cannot catch exceptions from on_click callbacks at all.
2. Tried setting a custom asyncio exception handler to catch errors, which also had no effect on on_click exceptions:

   import asyncio
   def exception_handler(loop, context):
       # My custom exception handling logic
       pass
   loop = asyncio.get_running_loop()
   loop.set_exception_handler(exception_handler)

My Questions

1. For Flet 0.80.5 in async mode on Win10, is there an official/recommended method to catch and handle exceptions in control event callbacks like on_click?
2. How can I handle the exception manually (e.g. show a friendly error message on the page) and keep the UI intact, instead of the app crashing with a traceback popup?

Env Info

• Flet version: 0.80.5
• OS: Windows 10
• App type: Flet desktop application (async mode)
• Python version: 3.13.1

Any solutions, code examples, or hints would be greatly appreciated! Thanks a lot for your help 😊

Code sample

import asyncio
from dataclasses import dataclass

import flet as ft

@dataclass
@ft.observable
class AppState:
    counter: float

    async def start_counter(self):
        self.counter = 0
        for _ in range(0, 10):
            self.counter += 0.1
            await asyncio.sleep(0.5)
            if self.counter>0.2:
                raise


@ft.component
def App():
    state, _ = ft.use_state(AppState(counter=0))

    return [
        ft.ProgressBar(state.counter),
        ft.Button("Run!", on_click=state.start_counter),
    ]

async def on_error(e):
    print('error') 

def exception_handler(loop, context):
    print("error")
async def main(page: ft.Page):
    loop = asyncio.get_running_loop()
    loop.set_exception_handler(exception_handler)
    page.on_error = on_error
    page.render(App)

asyncio.run(ft.run_async(main))

Error message

E:\data\Develop\test\test_flet>uv run main.py
Unhandled error in 'on_click' handler
Traceback (most recent call last):
  File "E:\data\Develop\test\test_flet\.venv\Lib\site-packages\flet\messaging\session.py", line 198, in dispatch_event
    await control._trigger_event(event_name, event_data)
  File "E:\data\Develop\test\test_flet\.venv\Lib\site-packages\flet\controls\base_control.py", line 318, in _trigger_event
    await event_handler()
  File "E:\data\Develop\test\test_flet\main.py", line 17, in start_counter
    raise
RuntimeError: No active exception to reraise

------------------------------------------------------

• I have searched for answers to my question both in the issues and in previous discussions.

[Avalon2222]

In 0.80.5, page.on_error doesn't see these exceptions. When a Python event handler raises, Session.dispatch_event catches the exception, logs Unhandled error in 'on_click' handler, and sends a SESSION_CRASHED message to the client. That message is what produces the traceback screen. It never goes through page.on_error or the asyncio exception handler, because the exception doesn't reach the event loop.

So the way to keep the UI alive is to catch the exception inside the handler. Rather than adding try/except everywhere, you can wrap handlers once with a small decorator:

import functools, inspect
import flet as ft

def safe(handler):
    @functools.wraps(handler)
    async def wrapper(*args, **kwargs):
        try:
            result = handler(*args, **kwargs)
            if inspect.isawaitable(result):
                await result
        except Exception as ex:
            ft.context.page.show_dialog(ft.SnackBar(ft.Text(f"Something went wrong: {ex}")))
    return wrapper


@ft.component
def App():
    state, _ = ft.use_state(AppState(counter=0))
    return [
        ft.ProgressBar(state.counter),
        ft.Button("Run!", on_click=safe(state.start_counter)),
    ]

functools.wraps matters here. Flet checks inspect.iscoroutinefunction(handler) and counts the handler's parameters to decide whether to call it with or without the event. With wraps, the wrapper reports the original signature: 0 parameters for state.start_counter, 1 for a normal def on_click(e). It works for both sync and async handlers. I checked this against flet 0.80.5's own get_param_count, and exceptions from both kinds of handler are caught instead of reaching dispatch_event. Any state changed before the exception (here counter) stays as it was, so the UI keeps its current state.

If you'd rather show a dialog, use ft.AlertDialog(...) with page.show_dialog() in the except block. You can also put logging.exception(...) there so you don't lose the traceback.