remove handler-subscription and enhance event typing (#3808)

sdk/python/packages/flet-core/src/flet_core/auto_complete.py

@@ -28,7 +28,7 @@ def __init__(
         self,
         suggestions: Optional[List[AutoCompleteSuggestion]] = None,
         suggestions_max_height: OptionalNumber = None,
-        on_select=None,
+        on_select: OptionalEventCallable["AutoCompleteSelectEvent"] = None,
         #
         # Control
         #
@@ -87,12 +87,12 @@ def suggestions(self, value: Optional[List[str]]):
 
     # on_select
     @property
-    def on_select(self):
-        return self._get_event_handler("select")
+    def on_select(self) -> OptionalEventCallable["AutoCompleteSelectEvent"]:
+        return self.__on_select.handler
 
     @on_select.setter
     def on_select(self, handler: OptionalEventCallable["AutoCompleteSelectEvent"]):
-        self.__on_select.subscribe(handler)
+        self.__on_select.handler = handler
 
 
 class AutoCompleteSelectEvent(ControlEvent):

sdk/python/packages/flet-core/src/flet_core/canvas/canvas.py

@@ -141,12 +141,12 @@ def resize_interval(self, value: OptionalNumber):
 
     # on_resize
     @property
-    def on_resize(self):
-        return self.__on_resize
+    def on_resize(self) -> OptionalEventCallable["CanvasResizeEvent"]:
+        return self.__on_resize.handler
 
     @on_resize.setter
     def on_resize(self, handler: OptionalEventCallable["CanvasResizeEvent"]):
-        self.__on_resize.subscribe(handler)
+        self.__on_resize.handler = handler
         self._set_attr("onresize", True if handler is not None else None)
 
 

sdk/python/packages/flet-core/src/flet_core/charts/bar_chart.py

@@ -407,12 +407,12 @@ def tooltip_direction(self, value: Optional[TooltipDirection]):
 
     # on_chart_event
     @property
-    def on_chart_event(self):
-        return self.__on_chart_event
+    def on_chart_event(self) -> OptionalEventCallable["BarChartEvent"]:
+        return self.__on_chart_event.handler
 
     @on_chart_event.setter
     def on_chart_event(self, handler: OptionalEventCallable["BarChartEvent"]):
-        self.__on_chart_event.subscribe(handler)
+        self.__on_chart_event.handler = handler
         self._set_attr("onChartEvent", True if handler is not None else None)
 
 

sdk/python/packages/flet-core/src/flet_core/charts/line_chart.py

@@ -453,12 +453,12 @@ def tooltip_border_side(self, value: Optional[BorderSide]):
 
     # on_chart_event
     @property
-    def on_chart_event(self):
-        return self.__on_chart_event
+    def on_chart_event(self) -> OptionalEventCallable["LineChartEvent"]:
+        return self.__on_chart_event.handler
 
     @on_chart_event.setter
     def on_chart_event(self, handler: OptionalEventCallable["LineChartEvent"]):
-        self.__on_chart_event.subscribe(handler)
+        self.__on_chart_event.handler = handler
         self._set_attr("onChartEvent", True if handler is not None else None)
 
 

sdk/python/packages/flet-core/src/flet_core/charts/pie_chart.py

@@ -168,12 +168,12 @@ def animate(self, value: AnimationValue):
 
     # on_chart_event
     @property
-    def on_chart_event(self):
-        return self.__on_chart_event
+    def on_chart_event(self) -> OptionalEventCallable["PieChartEvent"]:
+        return self.__on_chart_event.handler
 
     @on_chart_event.setter
     def on_chart_event(self, handler: OptionalEventCallable["PieChartEvent"]):
-        self.__on_chart_event.subscribe(handler)
+        self.__on_chart_event.handler = handler
         self._set_attr("onChartEvent", True if handler is not None else None)
 
 

sdk/python/packages/flet-core/src/flet_core/container.py

@@ -308,9 +308,7 @@ def blend_mode(self) -> Optional[BlendMode]:
     @blend_mode.setter
     def blend_mode(self, value: Optional[BlendMode]):
         self.__blend_mode = value
-        self._set_attr(
-            "blendMode", value.value if isinstance(value, BlendMode) else value
-        )
+        self._set_enum_attr("blendMode", value, BlendMode)
 
     # blur
     @property
@@ -582,12 +580,12 @@ def on_click(self, handler: OptionalControlEventCallable):
 
     # on_tap_down
     @property
-    def on_tap_down(self):
-        return self.__on_tap_down
+    def on_tap_down(self) -> OptionalEventCallable["ContainerTapEvent"]:
+        return self.__on_tap_down.handler
 
     @on_tap_down.setter
     def on_tap_down(self, handler: OptionalEventCallable["ContainerTapEvent"]):
-        self.__on_tap_down.subscribe(handler)
+        self.__on_tap_down.handler = handler
         self._set_attr("onTapDown", True if handler is not None else None)
 
     # on_long_press

sdk/python/packages/flet-core/src/flet_core/control.py

@@ -73,7 +73,7 @@ def __init__(
         self.data = data
         self.rtl = rtl
 
-        self.__event_handlers: Dict[str, OptionalEventCallable] = {}
+        self.__event_handlers: Dict[str, OptionalControlEventCallable] = {}
         self.parent: Optional[Control] = None
 
     def is_isolated(self) -> bool:
@@ -103,7 +103,7 @@ def _get_control_name(self) -> str:
         )
 
     def _add_event_handler(
-        self, event_name: str, handler: OptionalEventCallable
+        self, event_name: str, handler: OptionalControlEventCallable
     ) -> None:
         self.__event_handlers[event_name] = handler
 

sdk/python/packages/flet-core/src/flet_core/datatable.py

@@ -97,12 +97,12 @@ def tooltip(self, value: Optional[str]):
 
     # on_sort
     @property
-    def on_sort(self):
-        return self.__on_sort
+    def on_sort(self) -> OptionalEventCallable["DataColumnSortEvent"]:
+        return self.__on_sort.handler
 
     @on_sort.setter
-    def on_sort(self, handler: Optional[Callable[[DataColumnSortEvent], None]]):
-        self.__on_sort.subscribe(handler)
+    def on_sort(self, handler: OptionalEventCallable["DataColumnSortEvent"]):
+        self.__on_sort.handler = handler
         self._set_attr("onSort", True if handler is not None else None)
 
 
@@ -218,12 +218,12 @@ def on_tap_cancel(self, handler: OptionalControlEventCallable):
 
     # on_tap_down
     @property
-    def on_tap_down(self):
-        return self.__on_tap_down
+    def on_tap_down(self) -> OptionalEventCallable[TapEvent]:
+        return self.__on_tap_down.handler
 
     @on_tap_down.setter
-    def on_tap_down(self, handler: Optional[Callable[[TapEvent], None]]):
-        self.__on_tap_down.subscribe(handler)
+    def on_tap_down(self, handler: OptionalEventCallable[TapEvent]):
+        self.__on_tap_down.handler = handler
         self._set_attr("onTapDown", True if handler is not None else None)
 
 

sdk/python/packages/flet-core/src/flet_core/date_picker.py

@@ -378,11 +378,13 @@ def on_dismiss(self, handler: OptionalControlEventCallable):
 
     # on_entry_mode_change
     @property
-    def on_entry_mode_change(self):
-        return self.__on_entry_mode_change
+    def on_entry_mode_change(
+        self,
+    ) -> OptionalEventCallable[DatePickerEntryModeChangeEvent]:
+        return self.__on_entry_mode_change.handler
 
     @on_entry_mode_change.setter
     def on_entry_mode_change(
-        self, handler: Optional[Callable[[DatePickerEntryModeChangeEvent], None]]
+        self, handler: OptionalEventCallable[DatePickerEntryModeChangeEvent]
     ):
-        self.__on_entry_mode_change.subscribe(handler)
+        self.__on_entry_mode_change.handler = handler

sdk/python/packages/flet-core/src/flet_core/dismissible.py

@@ -247,34 +247,34 @@ def dismiss_thresholds(
 
     # on_dismiss
     @property
-    def on_dismiss(self):
-        return self._get_event_handler("dismiss")
+    def on_dismiss(self) -> OptionalEventCallable["DismissibleDismissEvent"]:
+        return self.__on_dismiss.handler
 
     @on_dismiss.setter
     def on_dismiss(self, handler: OptionalEventCallable["DismissibleDismissEvent"]):
-        self.__on_dismiss.subscribe(handler)
+        self.__on_dismiss.handler = handler
         self._set_attr("onDismiss", True if handler is not None else None)
 
     # on_confirm_dismiss
     @property
-    def on_confirm_dismiss(self):
-        return self._get_event_handler("confirm_dismiss")
+    def on_confirm_dismiss(self) -> OptionalEventCallable["DismissibleDismissEvent"]:
+        return self.__on_confirm_dismiss.handler
 
     @on_confirm_dismiss.setter
     def on_confirm_dismiss(
         self, handler: OptionalEventCallable["DismissibleDismissEvent"]
     ):
-        self.__on_confirm_dismiss.subscribe(handler)
+        self.__on_confirm_dismiss.handler = handler
         self._set_attr("onConfirmDismiss", True if handler is not None else None)
 
     # on_update
     @property
-    def on_update(self):
-        return self._get_event_handler("update")
+    def on_update(self) -> OptionalEventCallable["DismissibleUpdateEvent"]:
+        return self.__on_update.handler
 
     @on_update.setter
     def on_update(self, handler: OptionalEventCallable["DismissibleUpdateEvent"]):
-        self.__on_update.subscribe(handler)
+        self.__on_update.handler = handler
         self._set_attr("onUpdate", True if handler is not None else None)
 
     # on_resize

sdk/python/packages/flet-core/src/flet_core/drag_target.py

@@ -6,6 +6,7 @@
 from flet_core.control_event import ControlEvent
 from flet_core.event_handler import EventHandler
 from flet_core.ref import Ref
+from flet_core.types import OptionalControlEventCallable, OptionalEventCallable
 
 
 class DragTarget(Control):
@@ -106,10 +107,10 @@ def __init__(
         self,
         content: Control,
         group: Optional[str] = None,
-        on_will_accept=None,
-        on_accept=None,
-        on_leave=None,
-        on_move=None,
+        on_will_accept: OptionalControlEventCallable = None,
+        on_accept: OptionalEventCallable["DragTargetEvent"] = None,
+        on_leave: OptionalControlEventCallable = None,
+        on_move: OptionalEventCallable["DragTargetEvent"] = None,
         #
         # Control
         #
@@ -170,39 +171,39 @@ def content(self, value: Control):
 
     # on_will_accept
     @property
-    def on_will_accept(self):
+    def on_will_accept(self) -> OptionalControlEventCallable:
         return self._get_event_handler("will_accept")
 
     @on_will_accept.setter
-    def on_will_accept(self, handler):
+    def on_will_accept(self, handler: OptionalControlEventCallable):
         self._add_event_handler("will_accept", handler)
 
     # on_accept
     @property
-    def on_accept(self):
-        return self.__on_accept
+    def on_accept(self) -> OptionalEventCallable["DragTargetEvent"]:
+        return self.__on_accept.handler
 
     @on_accept.setter
-    def on_accept(self, handler):
-        self.__on_accept.subscribe(handler)
+    def on_accept(self, handler: OptionalEventCallable["DragTargetEvent"]):
+        self.__on_accept.handler = handler
 
     # on_leave
     @property
-    def on_leave(self):
+    def on_leave(self) -> OptionalControlEventCallable:
         return self._get_event_handler("leave")
 
     @on_leave.setter
-    def on_leave(self, handler):
+    def on_leave(self, handler: OptionalControlEventCallable):
         self._add_event_handler("leave", handler)
 
     # on_move
     @property
-    def on_move(self):
-        return self.__on_move
+    def on_move(self) -> OptionalEventCallable["DragTargetEvent"]:
+        return self.__on_move.handler
 
     @on_move.setter
-    def on_move(self, handler):
-        self.__on_move.subscribe(handler)
+    def on_move(self, handler: OptionalEventCallable["DragTargetEvent"]):
+        self.__on_move.handler = handler
 
 
 class DragTargetAcceptEvent(ControlEvent):

sdk/python/packages/flet-core/src/flet_core/event_handler.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Callable
+from typing import Callable, Optional
 
 from flet_core.control_event import ControlEvent
 from flet_core.types import OptionalControlEventCallable
@@ -8,11 +8,11 @@
 class EventHandler:
     def __init__(self, result_converter=None) -> None:
         self.__result_converter = result_converter
-        self.__handlers = {}
+        self.handler: OptionalControlEventCallable = None
 
     def get_handler(self):
         async def fn(e: ControlEvent):
-            for handler in self.__handlers.keys():
+            if self.handler is not None:
                 ce = e
                 if self.__result_converter is not None:
                     ce = self.__result_converter(e)
@@ -24,20 +24,9 @@ async def fn(e: ControlEvent):
                         ce.page = e.page
 
                 if ce is not None:
-                    if asyncio.iscoroutinefunction(handler):
-                        await handler(ce)
+                    if asyncio.iscoroutinefunction(self.handler):
+                        await self.handler(ce)
                     else:
-                        e.page.run_thread(handler, ce)
+                        e.page.run_thread(self.handler, ce)
 
         return fn
-
-    def subscribe(self, handler: OptionalControlEventCallable):
-        if handler is not None:
-            self.__handlers[handler] = True
-
-    def unsubscribe(self, handler: Callable[[ControlEvent], None]):
-        if handler in self.__handlers:
-            self.__handlers.pop(handler)
-
-    def count(self) -> int:
-        return len(self.__handlers)

sdk/python/packages/flet-core/src/flet_core/file_picker.py

@@ -7,6 +7,7 @@
 from flet_core.control_event import ControlEvent
 from flet_core.event_handler import EventHandler
 from flet_core.ref import Ref
+from flet_core.types import OptionalEventCallable
 from flet_core.utils import deprecated
 
 try:
@@ -329,18 +330,18 @@ def allow_multiple(self, value: Optional[bool]):
 
     # on_result
     @property
-    def on_result(self):
-        return self.__on_result
+    def on_result(self) -> OptionalEventCallable[FilePickerResultEvent]:
+        return self.__on_result.handler
 
     @on_result.setter
-    def on_result(self, handler: Optional[Callable[[FilePickerResultEvent], None]]):
-        self.__on_result.subscribe(handler)
+    def on_result(self, handler: OptionalEventCallable[FilePickerResultEvent]):
+        self.__on_result.handler = handler
 
     # on_upload
     @property
     def on_upload(self):
-        return self.__on_upload
+        return self.__on_upload.handler
 
     @on_upload.setter
-    def on_upload(self, handler: Optional[Callable[[FilePickerUploadEvent], None]]):
-        self.__on_upload.subscribe(handler)
+    def on_upload(self, handler: OptionalEventCallable[FilePickerUploadEvent]):
+        self.__on_upload.handler = handler