flet-easy 0.3.0.dev3__tar.gz → 0.3.0.dev5__tar.gz

{flet_easy-0.3.0.dev3 → flet_easy-0.3.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-easy
-Version: 0.3.0.dev3
+Version: 0.3.0.dev5
 Summary: ⚡Flet-Easy is a user-friendly add-on package for Flet, offering a cleaner code structure with numerous customizable features like JWT, routers, decorators, middleware and more.
 Project-URL: Homepage, https://github.com/Daxexs
 Project-URL: Repository, https://github.com/Daxexs/flet-easy

{flet_easy-0.3.0.dev3 → flet_easy-0.3.0.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flet-easy"
-version = "0.3.0.dev3"
+version = "0.3.0.dev5"
 description = "⚡Flet-Easy is a user-friendly add-on package for Flet, offering a cleaner code structure with numerous customizable features like JWT, routers, decorators, middleware and more."
 authors = [{ name = "Daxexs", email = "Daxexsdev@gmail.com" }]
 

{flet_easy-0.3.0.dev3 → flet_easy-0.3.0.dev5}/src/flet_easy/__init__.py

@@ -11,4 +11,3 @@ from flet_easy.inheritance import (
 )
 from flet_easy.jwt import EasyKey, decode, decode_async
 from flet_easy.pagesy import AddPagesy, Pagesy, MiddlewareRequest
-from flet_easy.extra import cache_control

{flet_easy-0.3.0.dev3 → flet_easy-0.3.0.dev5}/src/flet_easy/datasy.py

@@ -1,8 +1,8 @@
 from collections import deque
 from datetime import datetime, timedelta, timezone
-from typing import Any, Callable, Dict
+from typing import Any, Callable, Dict, Tuple
 
-from flet import Page
+from flet import Control, ControlEvent, Page
 
 from flet_easy.exceptions import LoginError
 from flet_easy.extra import Msg, Redirect
@@ -42,6 +42,7 @@ class Datasy:
     * `login` : method to create sessions of all sections in the browser (client storage), requires as parameters the key and the value, the same used in the `page.client_storage.set` method.
     * `go` : `go`: Method to change the application path, supports url redirections.
     * `go_back` : Method to go back to the previous route.
+    * `go_navigation_bar` : Handles navigation bar changes. Use this method in the on_change event of 'ft.NavigationBar' or 'ft.CupertinoNavigationBar' controls.
     * `history_routes` : Get the history of the routes.
     * `route` : route provided by the route event, it is useful when using middlewares to check if the route is assecible.
     * `redirect` : To redirect to a path before the page loads, it is used in middleware.
@@ -55,7 +56,7 @@ class Datasy:
         secret_key: str,
         auto_logout: bool,
         page_on_keyboard: Keyboardsy,
-        go: Callable[[str], None] = None,
+        go: Callable[[str, int], None] = None,
     ) -> None:
         self.__page: Page = None
         self.__url_params: Dict[str, Any] = None
@@ -68,7 +69,8 @@ class Datasy:
         self.__on_resize: Resizesy = None
         self.__route: str = None
         self.__go = go
-        self.__history_routes: deque[str] = deque()
+        self.__history_routes: deque[Tuple[str, int]] = deque()
+        self._dynamic_control: Dict[str, Tuple[Control, Callable[[Control], None]]] = {}
 
         self.__secret_key: SecretKey = secret_key
         self.__auto_logout: bool = auto_logout
@@ -89,10 +91,6 @@ class Datasy:
     def history_routes(self):
         return self.__history_routes
 
-    @history_routes.setter
-    def history_routes(self, history_routes: deque[str]):
-        self.__history_routes = history_routes
-
     @property
     def url_params(self):
         return self.__url_params
@@ -365,17 +363,34 @@ class Datasy:
         """To change the application path, it is important for better validation to avoid using `page.go()`."""
         return lambda _=None: self.__go(route)
 
+    def go_navigation_bar(self, e: ControlEvent) -> None:
+        """Handles navigation bar changes. Use this method in the on_change event of
+        'ft.NavigationBar' or 'ft.CupertinoNavigationBar' controls."""
+        self.__go(e.control.selected_index)
+
     def redirect(self, route: str):
         """Useful if you do not want to access a route that has already been sent."""
         return Redirect(route)
 
-    def go_back(self):
+    def go_back(self) -> Callable[[ControlEvent], None]:
         """Go back to the previous route."""
-        return lambda _=None: (
-            (self.history_routes.pop(), self.__go(self.history_routes.pop()))
-            if len(self.history_routes) > 1
-            else (print("-> I can't go back! There is no route history."), None)
-        )
+
+        def go_back_func():
+            if len(self.history_routes) > 1:
+                self.history_routes.pop()
+                route, index = self.history_routes.pop()
+                if index is not None:
+                    self.view.navigation_bar.selected_index = index
+
+                self.__go(route)
+            else:
+                print("-> I can't go back! there is no history. ")
+
+        return lambda _=None: go_back_func()
+
+    def dynamic_control(self, control: Control, func_update: Callable[[Control], None]) -> None:
+        """Adds dynamic control to the page."""
+        self._dynamic_control[self.page.route] = (control, func_update)
 
 
 def evaluate_secret_key(data: Datasy):

flet_easy-0.3.0.dev5/src/flet_easy/extra.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from re import Pattern, compile
+from typing import Callable, Dict, Optional, Tuple
+
+
+@dataclass
+class Msg:
+    method: str
+    key: str = None
+    value: str | dict = None
+
+
+@dataclass
+class Redirect:
+    route: str = None
+
+
+TYPE_PATTERNS: Dict[str, Tuple[Pattern[str], Callable[[str], Optional[bool]]]] = {
+    "int": (compile(r"-?\d+"), int),
+    "float": (compile(r"-?\d+\.\d+"), float),
+    "str": (compile(r"[^/]+"), str),
+    "bool": (compile(r"(true|True|false|False)"), lambda x: x in ["true", "True"]),
+}

{flet_easy-0.3.0.dev3 → flet_easy-0.3.0.dev5}/src/flet_easy/fletEasy.py

@@ -126,6 +126,20 @@ class FletEasy(FletEasyX):
     """
 
     __self = None
+    __slots__ = (
+        "__route_prefix",
+        "__path_views",
+        "__pagesys",
+        "_data",
+        "_pages",
+        "_page_404",
+        "_view_data",
+        "_view_config",
+        "_config_login",
+        "_config_event",
+        "_middlewares",
+        "_middlewares_after",
+    )
 
     def __init__(
         self,
@@ -155,7 +169,7 @@ class FletEasy(FletEasyX):
         # add data to middleware request
         MiddlewareRequest._data = self._data
 
-        self.__pagesys = automatic_routing(self.__path_views)
+        self.__pagesys = automatic_routing(self.__path_views) if self.__path_views else None
 
     # -------------------------------------------------------------------
     def __pre_config(self, page: Page):
@@ -248,6 +262,7 @@ class FletEasy(FletEasyX):
                         route=route,
                         view=func,
                         title=data.get("title"),
+                        index=data.get("index"),
                         clear=data.get("page_clear"),
                         share_data=data.get("share_data"),
                         protected_route=data.get("protected_route"),
@@ -283,6 +298,7 @@ class FletEasy(FletEasyX):
         cls,
         route: str,
         title: str = None,
+        index: Optional[int] = None,
         page_clear: bool = False,
         share_data: bool = False,
         protected_route: bool = False,
@@ -295,6 +311,7 @@ class FletEasy(FletEasyX):
         """Decorator to add a new page to the app, you need the following parameters:
         * route: text string of the url, for example(`'/FletEasy'`).
         * `title` : Define the title of the page. (optional).
+        * `index` : Define the index of the page, use in controls like `ft.CupertinoNavigationBar` or `ft.NavigationBar`. (optional)
         * clear: Removes the pages from the `page.views` list of flet. (optional)
         * `share_data` : It is a boolean value, which is useful if you want to share data between pages, in a more restricted way. (optional)
         * protected_route: Protects the route of the page, according to the configuration of the `login` decorator of the `FletEasy` class. (optional)
@@ -329,6 +346,7 @@ class FletEasy(FletEasyX):
         data = {
             "route": route,
             "title": title,
+            "index": index,
             "page_clear": page_clear,
             "share_data": share_data,
             "protected_route": protected_route,

{flet_easy-0.3.0.dev3 → flet_easy-0.3.0.dev5}/src/flet_easy/pagesy.py

@@ -15,6 +15,7 @@ class Pagesy:
     * `route`: text string of the url, for example(`'/task'`).
     * `view`: Stores the page function.
     * `title` : Define the title of the page.
+    * `index` : Define the index of the page, use in controls like `ft.NavigationBar` and `ft.CupertinoNavigationBar`.
     * `clear`: Removes the pages from the `page.views` list of flet. (optional)
     * `share_data` : It is a boolean value, which is useful if you want to share data between pages, in a more restricted way. (optional)
     * `protected_route`: Protects the route of the page, according to the configuration of the `login` decorator of the `FletEasy` class. (optional)
@@ -33,6 +34,7 @@ class Pagesy:
         route: str,
         view: ViewHandler,
         title: Optional[str] = None,
+        index: Optional[int] = None,
         clear: bool = False,
         share_data: bool = False,
         protected_route: bool = False,
@@ -45,6 +47,7 @@ class Pagesy:
         self.route = route
         self.view = view
         self.title = title
+        self.index = index
         self.clear = clear
         self.share_data = share_data
         self.protected_route = protected_route
@@ -178,6 +181,7 @@ class AddPagesy:
         self,
         route: str,
         title: Optional[str] = None,
+        index: Optional[int] = None,
         page_clear: bool = False,
         share_data: bool = False,
         protected_route: bool = False,
@@ -199,6 +203,7 @@ class AddPagesy:
                     route=self.__build_route(route),
                     view=func,
                     title=title,
+                    index=index,
                     clear=page_clear,
                     share_data=share_data,
                     protected_route=protected_route,

{flet_easy-0.3.0.dev3 → flet_easy-0.3.0.dev5}/src/flet_easy/route.py

@@ -39,6 +39,7 @@ class FletEasyX:
         self._pages = deque()
         self.__history_pages: Dict[str, View] = {}
         self.__view_404 = page_404_fs
+        self.__automatically_imply_leading = False
 
         self.__page: Page = None
         self._page_404: Pagesy = None
@@ -76,9 +77,7 @@ class FletEasyX:
             self.__pagesy = None
 
     def __view_pop(self, e: ViewPopEvent):
-        if len(self._data.history_routes) > 1:
-            self._data.history_routes.pop()
-            self._go(self._data.history_routes.pop())
+        self._data.go_back()()
 
     async def __on_keyboard(self, e: KeyboardEvent):
         self.__page_on_keyboard.call = e
@@ -125,13 +124,17 @@ class FletEasyX:
         """Add the `View` configuration, to reuse on every page."""
         self._data.view = self.__check_async(self._view_data, self._data, result=True)
 
+        if self._data.view:
+            self.__automatically_imply_leading = getattr(
+                self._data.view.appbar, "automatically_imply_leading", True
+            )
+
         if self.__route_login is not None:
             self._data._create_login()
 
     def _add_configuration_start(self, page: Page):
         """Add general settings to the pages."""
         self.__page = page
-        self.__page.views.clear()
         self.__config_datasy()
 
         """ Add view configuration """
@@ -150,7 +153,7 @@ class FletEasyX:
         """ Executing charter events """
         self.__page.on_route_change = self.__route_change
         self.__page.on_view_pop = self.__view_pop
-        self.__page.on_error = lambda e: print("Page error:", e.data)
+        self.__page.on_error = lambda e: print("Page error:", e)
         self.__page.on_disconnect = self.__disconnect
 
         """ activation of charter events """
@@ -167,8 +170,10 @@ class FletEasyX:
         """Add a new page and update it."""
 
         # To make the page change faster.
-        if len(self.__page.views) == 2:
-            self.__page.views.remove(self.__page.views[1])
+        self.__manage_dynamic_appbar(route)
+
+        if len(self.__page.views) > 1:
+            self.__page.views.pop()
 
         view = self.__history_pages.get(route)
 
@@ -186,8 +191,13 @@ class FletEasyX:
             if pagesy.cache:
                 self.__history_pages[route] = view
 
+        dynamic_control = self._data._dynamic_control.get(route)
+
+        if dynamic_control:
+            self.__check_async(dynamic_control[1], dynamic_control[0], result=True)
+
         self.__page.views.append(view)
-        self._data.history_routes.append(route)
+        self._data.history_routes.append((route, pagesy.index))
         self.__page.update()
 
         if self._middlewares_after:
@@ -198,6 +208,21 @@ class FletEasyX:
             for middleware in pagesy._middlewares_request:
                 self.__check_async(middleware.after_request)
 
+    def __manage_dynamic_appbar(self, route: str) -> None:
+        """Manage the appbar automatically_imply_leading parameter"""
+        if route == self.__route_init:
+            self._data.history_routes.clear()
+            appbar = getattr(self._data.view, "appbar", None)
+
+            if appbar and getattr(appbar, "automatically_imply_leading", None):
+                appbar.automatically_imply_leading = False
+
+        elif self.__automatically_imply_leading:
+            appbar = getattr(self._data.view, "appbar", None)
+
+            if appbar:
+                appbar.automatically_imply_leading = True
+
     def __reload_datasy(
         self,
         pagesy: Pagesy,
@@ -249,107 +274,92 @@ class FletEasyX:
 
         return False
 
-    def __run_middlewares(
-        self,
-        route: str,
-        middleware: Middleware,
-        url_params: Dict[str, Any],
-        pagesy: Pagesy,
-        use_route_change: bool,
-        use_reload: bool,
-    ):
-        """Controla los middleware de la aplicación en general y en cada una de las páginas."""
-
-        if self.__execute_middleware(pagesy, url_params, middleware):
-            return True
+    def _go(self, route: Union[str, int], use_route_change: bool = False, use_reload: bool = False):
+        """method to go to the route, if the route is not found, it will return a 404 page."""
+        pg_404 = True
 
-        if self.__execute_middleware(pagesy, url_params, pagesy.middleware):
-            return True
+        for page in self._pages:
+            if isinstance(route, int):
+                if page.index != route:
+                    continue
+                route = page.route
 
-        self.__reload_datasy(pagesy, url_params)
-        if use_route_change:
-            self._view_append(route, pagesy)
-        else:
-            if self.__page.route != route or use_reload:
-                self.__pagesy = pagesy
-            self.__page.go(route)
+            route_match = self._verify_url(page.route, route, page.custom_params)
 
-        return True
+            if route_match is None:
+                continue
 
-    def _go(self, route: str, use_route_change: bool = False, use_reload: bool = False):
-        """Go to the route, if the route is not found, it will return a 404 page."""
-        pg_404 = True
+            pg_404 = False
 
-        for page in self._pages:
-            route_math = self._verify_url(page.route, route, page.custom_params)
-            if route_math is not None:
-                pg_404 = False
-                try:
-                    if page.protected_route:
-                        self.__check_protected_route(
-                            page,
-                            route,
-                            route_math,
-                            use_route_change,
-                            use_reload,
-                        )
-                        break
-                    else:
-                        if self.__run_middlewares(
-                            route,
-                            self._middlewares,
-                            route_math,
-                            page,
-                            use_route_change,
-                            use_reload,
-                        ):
-                            break
-                except Exception as e:
-                    raise RouteError(e)
-        if pg_404:
-            page = self._page_404 or Pagesy(route, self.__view_404, "Flet-Easy 404")
+            try:
+                if page.protected_route:
+                    if not self.__check_protected_route_optimized(
+                        page, route, route_match, use_route_change, use_reload
+                    ):
+                        return
+                    break
 
-            if page.route is None:
-                page.route = route
+                if self.__run_middlewares_optimized(
+                    route, route_match, page, use_route_change, use_reload
+                ):
+                    break
 
-            self.__reload_datasy(page)
+            except Exception as e:
+                raise RouteError(e)
 
-            if use_route_change:
-                self._view_append(page.route, page)
-            else:
-                if self.__page.route != route or use_reload:
-                    self.__pagesy = page
-                self.__page.go(page.route)
+        if pg_404:
+            self._handle_404_case(route, use_route_change, use_reload)
 
-    def __check_protected_route(
-        self, page: Pagesy, route: str, route_math: str, use_route_change: bool, use_reload: bool
+    def __check_protected_route_optimized(
+        self, page, route, route_match, use_route_change, use_reload
     ):
-        """Check if the route is protected and if it is, check if the user is logged in."""
-        assert self.__route_login is not None, (
-            "Configure the route of the login page, in the Flet-Easy class in the parameter (route_login)"
-        )
+        """Optimized protected route checker"""
+        if self.__route_login is None:
+            raise AssertionError("Configure the route of the login page in Flet-Easy class")
 
         try:
             auth = self.__check_async(self._config_login, self._data, result=True)
+            if not auth:
+                self._go(self.__route_login)
+                return False
+
+            self.__reload_datasy(page, route_match)
+            self._navigate(route, page, use_route_change, use_reload)
+            return True
         except Exception as e:
             raise LoginRequiredError(
-                "Use async methods in the function decorated by 'login', to avoid conflicts.",
-                e,
+                "use async methods in the function decorated by 'login', to avoid conflicts.", e
             )
 
-        if auth:
-            self.__reload_datasy(page, route_math)
+    def __run_middlewares_optimized(self, route, route_match, page, use_route_change, use_reload):
+        """Optimized middleware runner"""
+        if self._middlewares and self.__execute_middleware(page, route_match, self._middlewares):
+            return True
 
-            if use_route_change:
-                self._view_append(route, page)
+        if page.middleware and self.__execute_middleware(page, route_match, page.middleware):
+            return True
 
-            else:
-                if self.__page.route != route or use_reload:
-                    self.__pagesy = page
-                self.__page.go(route)
+        self.__reload_datasy(page, route_match)
+        self._navigate(route, page, use_route_change, use_reload)
+        return True
 
+    def _navigate(self, route, page, use_route_change, use_reload):
+        """Unified navigation handler"""
+        if use_route_change:
+            self._view_append(route, page)
         else:
-            self._go(self.__route_login)
+            if self.__page.route != route or use_reload:
+                self.__pagesy = page
+            self.__page.go(route)
+
+    def _handle_404_case(self, route, use_route_change, use_reload):
+        """Optimized 404 handler"""
+        page = self._page_404 or Pagesy(route, self.__view_404, "Flet-Easy 404")
+        if page.route is None:
+            page.route = route
+
+        self.__reload_datasy(page)
+        self._navigate(page.route, page, use_route_change, use_reload)
 
     @classmethod
     def __compile_pattern(cls, pattern_parts: list[str]) -> Pattern[str]:

{flet_easy-0.3.0.dev3 → flet_easy-0.3.0.dev5}/tests/cache-pages/pyproject.toml

@@ -2,7 +2,7 @@
 name = "flet-app"
 version = "0.1.0"
 license = "MIT"
-dependencies = ["flet", "flet-easy==0.3.0.dev2", "sqlmodel"]
+dependencies = ["flet", "flet-easy==0.3.0.dev4"]
 
 [[project.authors]]
 name = "Daxexs"

{flet_easy-0.3.0.dev3 → flet_easy-0.3.0.dev5}/tests/cache-pages/witch-main.py

@@ -5,7 +5,7 @@ import flet as ft
 
 import flet_easy as fs
 
-app = fs.FletEasy()
+app = fs.FletEasy(route_init="/")
 
 
 # remove animation on route change
@@ -31,6 +31,7 @@ def config_view(data: fs.Datasy):
         data.page.update()
 
     appbar = ft.AppBar(
+        # automatically_imply_leading=False,
         bgcolor=ft.Colors.BLACK45,
         actions=[
             ft.IconButton(
@@ -41,16 +42,6 @@ def config_view(data: fs.Datasy):
         ],
     )
 
-    def index_bar_route(e: ft.ControlEvent):
-        route = e.control.selected_index
-
-        if route == 0:
-            data.go("/")()
-        elif route == 1:
-            data.go("/test2")()
-        elif route == 2:
-            data.go("/test3")()
-
     return ft.View(
         appbar=appbar,
         navigation_bar=ft.NavigationBar(
@@ -62,7 +53,7 @@ def config_view(data: fs.Datasy):
                     label="counter 3",
                 ),
             ],
-            on_change=index_bar_route,
+            on_change=data.go_navigation_bar,
         ),
     )
 
@@ -94,79 +85,69 @@ class Counter(ft.Container):
 
 
 # add cache to the page
-@app.page("/", title="Test 1", cache=True)
+@app.page("/", title="Test 1", index=0, cache=True)
 def index_page(data: fs.Datasy):
     page = data.page
-    new_appbar = fs.cache_control(data.view.appbar)
-    new_appbar.title = ft.Text("Test 1")
+    appbar = data.view.appbar
+
+    async def update_title(e: ft.AppBar):
+        e.title = ft.Text("Test 1")
+
+    data.dynamic_control(appbar, update_title)
 
     return ft.View(
         controls=[
             ft.Text("Counter 1", size=50),
             Counter(page.update, ft.Colors.RED),
         ],
-        appbar=new_appbar,
+        appbar=appbar,
         navigation_bar=data.view.navigation_bar,
         horizontal_alignment="center",
         vertical_alignment="center",
     )
 
 
-def m(data: fs.Datasy):
-    page = data.page
-    page.run_task(x)
-
-
-@app.page("/test2", title="Test 2", middleware=[m])
+@app.page("/test2", title="Test 2", index=1)
 def test_page(data: fs.Datasy):
     page = data.page
-    data.view.appbar.title = ft.Text("Test 2")
+    appbar = data.view.appbar
+
+    appbar.title = ft.Text("Test 2")
 
     return ft.View(
         controls=[
             ft.Text("Counter 2 - (cache disabled)", size=50),
             Counter(page.update, ft.Colors.BLUE),
         ],
-        appbar=data.view.appbar,
+        appbar=appbar,
         navigation_bar=data.view.navigation_bar,
         vertical_alignment="center",
         horizontal_alignment="center",
     )
 
 
-async def x():
-    for i in range(10):
-        print(i)
-        await asyncio.sleep(1)
-    return "Done"
-
-
 # add cache to the page
-@app.page("/test3", title="Test 3", cache=True)
+@app.page("/test3", title="Test 3", index=2, cache=True)
 async def test2_page(data: fs.Datasy):
     page = data.page
-    new_appbar = fs.cache_control(data.view.appbar)
-    new_appbar.title = ft.Text("Test 3")
+    appbar = data.view.appbar
 
-    page.run_task(x)
+    data.dynamic_control(appbar, func_update=lambda e: setattr(e, "title", ft.Text("Test 3")))
+    data.dynamic_control(
+        appbar,
+        func_update=lambda e: setattr(e, "automatically_imply_leading", False),
+    )
 
     return ft.View(
         controls=[
             ft.Text("Counter 3", size=50),
             Counter(page.update, ft.Colors.GREEN),
         ],
-        appbar=new_appbar,
+        appbar=appbar,
         navigation_bar=data.view.navigation_bar,
         horizontal_alignment="center",
         vertical_alignment="center",
     )
 
 
-async def main(page: ft.Page):
-    app.start(page)
-
-
-# app.run()
-if __name__ == "__main__":
-    #ft.app(target=main)
-    app.run()
+app.run()