Release v0.1.5

- Decorator-based Route Registration

Author: fasilwdr

README.md

@@ -23,12 +23,11 @@ pip install flet-model
 
 ```python
 import flet as ft
-from flet_model import Model, Router
+from flet_model import Model, route
 
 
+@route('home')
 class HomeModel(Model):
-    route = 'home'
-
     # Layout configuration
     vertical_alignment = ft.MainAxisAlignment.CENTER
     horizontal_alignment = ft.CrossAxisAlignment.CENTER
@@ -51,9 +50,8 @@ class HomeModel(Model):
         self.page.go('/home/profile')
 
 
+@route('profile')
 class ProfileModel(Model):
-    route = 'profile'
-
     # Layout configuration
     vertical_alignment = ft.MainAxisAlignment.CENTER
     horizontal_alignment = ft.CrossAxisAlignment.CENTER
@@ -74,11 +72,8 @@ class ProfileModel(Model):
 
 def main(page: ft.Page):
     page.title = "Flet Model Demo"
-    Router(
-        {'home': HomeModel(page)},
-        {'profile': ProfileModel(page)},
-    )
-    page.go(page.route)
+    # Router is automatically initialized
+    page.go('/home')
 
 
 ft.app(target=main)
@@ -92,6 +87,7 @@ ft.app(target=main)
 # Navigate with data
 self.page.go('/products#id=123&category=electronics')
 
+@route('products')
 class ProductModel(Model):
     def init(self):
         # Access route data
@@ -102,6 +98,7 @@ class ProductModel(Model):
 ### 2. Navigation Drawers
 
 ```python
+@route('drawer-demo')
 class DrawerModel(Model):
     drawer = ft.NavigationDrawer(
         controls=[
@@ -131,6 +128,7 @@ class DrawerModel(Model):
 ### 3. Event Handlers and Lifecycle Hooks
 
 ```python
+@route('events')
 class EventModel(Model):
     def init(self):
         # Called before view creation
@@ -152,6 +150,7 @@ class EventModel(Model):
 ### 4. Floating Action Button
 
 ```python
+@route('fab-demo')
 class FABModel(Model):
     floating_action_button = ft.FloatingActionButton(
         icon=ft.Icons.ADD,
@@ -163,6 +162,7 @@ class FABModel(Model):
 ### 5. Bottom Navigation
 
 ```python
+@route('navigation')
 class NavigationModel(Model):
     navigation_bar = ft.NavigationBar(
         destinations=[
@@ -176,6 +176,7 @@ class NavigationModel(Model):
 ### 6. Overlay Controls
 
 ```python
+@route('overlay')
 class OverlayModel(Model):
     overlay_controls = [
         ft.Banner(
@@ -194,8 +195,8 @@ class OverlayModel(Model):
 ### 7. Fullscreen Dialogs
 
 ```python
+@route('dialog')
 class DialogModel(Model):
-    route = "dialog"
     fullscreen_dialog = True
 
     controls = [
@@ -214,7 +215,7 @@ Here's a complete example of a todo application using Flet Model:
 
 ```python
 import flet as ft
-from flet_model import Model, Router
+from flet_model import Model, route
 from typing import List
 
 
@@ -224,8 +225,8 @@ class TodoItem:
         self.completed = completed
 
 
+@route('todo')
 class TodoModel(Model):
-    route = "todo"
     todos: List[TodoItem] = []
 
     appbar = ft.AppBar(
@@ -275,9 +276,7 @@ class TodoModel(Model):
 
 
 def main(page: ft.Page):
-    Router(
-        {'todo': TodoModel(page)}
-    )
+    # No manual router initialization needed
     page.go('todo')
 
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flet-model"
-version = "0.1.4"
+version = "0.1.5"
 description = "A Model-based router for Flet applications that simplifies the creation of multi-page applications"
 readme = "README.md"
 authors = [{ name = "Fasil", email = "fasilwdr@hotmail.com" }]

src/flet_model/__init__.py

@@ -1,6 +1,6 @@
 from .model import Model
-from .router import Router
+from .router import Router, route
 
-__version__ = "0.1.4"
+__version__ = "0.1.5"
 
-__all__ = ["Model", "Router"]
+__all__ = ["Model", "Router", "route"]

src/flet_model/router.py

@@ -1,8 +1,44 @@
-from typing import Dict, Optional, Type, Any
+from typing import Dict, Optional, Type, Any, Callable, TypeVar, List, Tuple
 import urllib.parse
 import flet as ft
 from .model import Model
 
+# Type variable for decorator return type annotation
+T = TypeVar('T', bound=Type[Model])
+
+# Global storage for route registrations
+_pending_registrations: List[Tuple[str, Type[Model]]] = []
+
+
+def route(route_path: str) -> Callable[[T], T]:
+    """
+    Decorator for registering a model class with a specific route.
+
+    Example:
+        @route('todo')
+        class TodoModel(Model):
+            # model implementation
+
+    Args:
+        route_path: The route path to register
+
+    Returns:
+        The decorated model class
+    """
+
+    def decorator(model_class: T) -> T:
+        if not issubclass(model_class, Model):
+            raise TypeError(f"Class {model_class.__name__} must inherit from Model")
+
+        # Store the route in the class for reference
+        model_class.route = route_path
+
+        # Save for deferred registration
+        _pending_registrations.append((route_path, model_class))
+        return model_class
+
+    return decorator
+
 
 class Router:
     """Router class for handling navigation in Flet applications."""
@@ -11,22 +47,29 @@ class Router:
     _routes: Dict[str, Model] = {}
     _page: Optional[ft.Page] = None
     _view_cache: Dict[str, ft.View] = {}
+    _initialized: bool = False
 
     def __new__(cls, *args, **kwargs):
         if cls._instance is None:
             cls._instance = super(Router, cls).__new__(cls)
         return cls._instance
 
     def __init__(self, *route_maps: Dict[str, Model]):
-        if not self._routes:
-            self._routes = {}
-            for route_map in route_maps:
-                self._routes.update(route_map)
+        if self._initialized:
+            return
+
+        self._routes = {}
 
-            if route_maps and list(route_maps[0].values()):
-                first_model = list(route_maps[0].values())[0]
-                self._page = first_model.page
-                self._setup_routing()
+        # Add any routes from explicit dictionaries
+        for route_map in route_maps:
+            self._routes.update(route_map)
+
+        # If we have routes and a page from dict-based initialization
+        if route_maps and list(route_maps[0].values()):
+            first_model = list(route_maps[0].values())[0]
+            self._page = first_model.page
+            self._setup_routing()
+            self._initialized = True
 
     def _parse_route_and_hash(self, route: str) -> tuple[list[str], dict[str, dict]]:
         parts = route.split('/')
@@ -47,7 +90,6 @@ def _parse_route_and_hash(self, route: str) -> tuple[list[str], dict[str, dict]]
 
         return route_parts, hash_data
 
-
     def _setup_routing(self) -> None:
         """Set up route handling and initialize default route."""
         if not self._page:
@@ -56,11 +98,6 @@ def _setup_routing(self) -> None:
         self._page.on_route_change = self._handle_route_change
         self._page.on_view_pop = self._handle_view_pop
 
-        if not self._page.route or self._page.route == '/':
-            default_route = next(iter(self._routes.keys()))
-            self._page.route = default_route
-            self._page.go(default_route)
-
     def _handle_route_change(self, e: ft.RouteChangeEvent) -> None:
         route_parts, hash_data = self._parse_route_and_hash(self._page.route.lstrip('/'))
         self._page.views.clear()
@@ -104,4 +141,63 @@ def get_current_model(cls) -> Optional[Model]:
             return None
 
         current_route = cls._instance._page.route.split('/')[-1]
-        return cls._instance._routes.get(current_route)
+        return cls._instance._routes.get(current_route)
+
+    # Auto-initialize with the page when app starts
+    @classmethod
+    def initialize(cls, page: ft.Page) -> None:
+        """
+        Initialize the router with a page and register any pending routes.
+        This also sets up the route handlers.
+
+        Args:
+            page: The flet Page instance
+        """
+        global _pending_registrations
+
+        # Create instance if it doesn't exist
+        if not cls._instance:
+            cls._instance = cls()
+
+        cls._instance._page = page
+        cls._instance._initialized = True
+
+        # Register any routes that were decorated
+        for route_path, model_class in _pending_registrations:
+            model_instance = model_class(page)
+            cls._instance._routes[route_path] = model_instance
+
+        # Clear pending registrations
+        _pending_registrations = []
+
+        # Setup routing
+        cls._instance._setup_routing()
+
+        # Return the instance for method chaining if needed
+        return cls._instance
+
+    @classmethod
+    def navigate(cls, route: str) -> None:
+        """
+        Navigate to a specific route, ensuring the router is initialized first.
+
+        Args:
+            route: The route to navigate to
+        """
+        if cls._instance and cls._instance._page:
+            cls._instance._page.go(route)
+
+
+# Modify flet.Page to inject our router
+def enhanced_page_go(self, route, *args, **kwargs):
+    """Enhanced go method that ensures router is initialized before navigation"""
+    # Initialize router if there are pending routes
+    if _pending_registrations and not Router._instance:
+        Router.initialize(self)
+    # Call the original go method
+    original_go(self, route, *args, **kwargs)
+
+
+# Store original method and apply patch
+original_go = ft.Page.go
+ft.Page.go = enhanced_page_go