flet-web 0.29.0.dev5039__py3-none-any.whl → 0.70.0.dev5066__py3-none-any.whl

flet_web/fastapi/flet_app_manager.py

@@ -1,17 +1,14 @@
 import asyncio
 import logging
 import shutil
-import threading
 import traceback
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
 from typing import Optional
 
-from flet.core.connection import Connection
-from flet.core.locks import NopeLock
-from flet.core.page import Page
-from flet.core.pubsub.pubsub_hub import PubSubHub
-from flet.utils import is_pyodide
+from flet.messaging.connection import Connection
+from flet.messaging.session import Session
+from flet.pubsub.pubsub_hub import PubSubHub
 
 import flet_web.fastapi as flet_fastapi
 from flet_web.fastapi.oauth_state import OAuthState
@@ -25,15 +22,12 @@ class FletAppManager:
     """
 
     def __init__(self):
-        self.__sessions_lock = asyncio.Lock()
-        self.__sessions: dict[str, Page] = {}
+        self.__sessions: dict[str, Session] = {}
         self.__evict_sessions_task = None
         self.__states: dict[str, OAuthState] = {}
-        self.__states_lock = threading.Lock() if not is_pyodide() else NopeLock()
         self.__evict_oauth_states_task = None
         self.__temp_dirs = {}
         self.__executor = ThreadPoolExecutor(thread_name_prefix="flet_fastapi")
-        self.__pubsubhubs_lock = threading.Lock() if not is_pyodide() else NopeLock()
         self.__pubsubhubs = {}
 
     @property
@@ -43,19 +37,19 @@ class FletAppManager:
     def get_pubsubhub(
         self, session_handler, loop: Optional[asyncio.AbstractEventLoop] = None
     ):
-        with self.__pubsubhubs_lock:
-            psh = self.__pubsubhubs.get(session_handler, None)
-            if psh is None:
-                psh = PubSubHub(
-                    loop=loop or asyncio.get_running_loop(),
-                    executor=self.__executor,
-                )
-                self.__pubsubhubs[session_handler] = psh
-            return psh
+        psh = self.__pubsubhubs.get(session_handler, None)
+        if psh is None:
+            psh = PubSubHub(
+                loop=loop or asyncio.get_running_loop(),
+                executor=self.__executor,
+            )
+            self.__pubsubhubs[session_handler] = psh
+        return psh
 
     async def start(self):
         """
-        Background task evicting expired app data. Must be called at FastAPI application startup.
+        Background task evicting expired app data. Must be called at FastAPI
+        application startup.
         """
         if not self.__evict_sessions_task:
             logger.info("Starting up Flet App Manager")
@@ -77,44 +71,31 @@ class FletAppManager:
         if self.__evict_oauth_states_task:
             self.__evict_oauth_states_task.cancel()
 
-    async def get_session(self, session_id: str) -> Optional[Page]:
-        async with self.__sessions_lock:
-            return self.__sessions.get(session_id)
+    async def get_session(self, session_id: str) -> Optional[Session]:
+        return self.__sessions.get(session_id)
 
-    async def add_session(self, session_id: str, conn: Page):
-        async with self.__sessions_lock:
-            self.__sessions[session_id] = conn
-            logger.info(
-                f"New session created ({len(self.__sessions)} total): {session_id}"
-            )
+    async def add_session(self, session_id: str, session: Session):
+        self.__sessions[session_id] = session
+        logger.info(f"New session created ({len(self.__sessions)} total): {session_id}")
 
     async def reconnect_session(self, session_id: str, conn: Connection):
         logger.info(f"Session reconnected: {session_id}")
-        async with self.__sessions_lock:
-            if session_id in self.__sessions:
-                page = self.__sessions[session_id]
-                old_conn = page.connection
-                await page._connect(conn)
-                if old_conn:
-                    old_conn.dispose()
+        if session_id in self.__sessions:
+            session = self.__sessions[session_id]
+            await session.connect(conn)
 
     async def disconnect_session(self, session_id: str, session_timeout_seconds: int):
         logger.info(f"Session disconnected: {session_id}")
-        async with self.__sessions_lock:
-            if session_id in self.__sessions:
-                await self.__sessions[session_id]._disconnect(session_timeout_seconds)
+        if session_id in self.__sessions:
+            await self.__sessions[session_id].disconnect(session_timeout_seconds)
 
     async def delete_session(self, session_id: str):
-        async with self.__sessions_lock:
-            page = self.__sessions.pop(session_id, None)
-            total = len(self.__sessions)
-        if page is not None:
+        session = self.__sessions.pop(session_id, None)
+        total = len(self.__sessions)
+        if session is not None:
             logger.info(f"Delete session ({total} left): {session_id}")
             try:
-                old_conn = page.connection
-                page._close()
-                if old_conn:
-                    old_conn.dispose()
+                session.close()
             except Exception as e:
                 logger.error(
                     f"Error deleting expired session: {e} {traceback.format_exc()}"
@@ -122,12 +103,10 @@ class FletAppManager:
 
     def store_state(self, state_id: str, state: OAuthState):
         logger.info(f"Store oauth state: {state_id}")
-        with self.__states_lock:
-            self.__states[state_id] = state
+        self.__states[state_id] = state
 
     def retrieve_state(self, state_id: str) -> Optional[OAuthState]:
-        with self.__states_lock:
-            return self.__states.pop(state_id, None)
+        return self.__states.pop(state_id, None)
 
     def add_temp_dir(self, temp_dir: str):
         self.__temp_dirs[temp_dir] = True
@@ -136,30 +115,28 @@ class FletAppManager:
         while True:
             await asyncio.sleep(10)
             session_ids = []
-            async with self.__sessions_lock:
-                for session_id, page in self.__sessions.items():
-                    if page.expires_at and datetime.now(timezone.utc) > page.expires_at:
-                        session_ids.append(session_id)
+            for session_id, session in self.__sessions.items():
+                if (
+                    session.expires_at
+                    and datetime.now(timezone.utc) > session.expires_at
+                ):
+                    session_ids.append(session_id)
             for session_id in session_ids:
                 await self.delete_session(session_id)
 
     async def __evict_expired_oauth_states(self):
         while True:
             await asyncio.sleep(10)
-            with self.__states_lock:
-                ids = []
-                for id, state in self.__states.items():
-                    if (
-                        state.expires_at
-                        and datetime.now(timezone.utc) > state.expires_at
-                    ):
-                        ids.append(id)
+            ids = []
+            for id, state in self.__states.items():
+                if state.expires_at and datetime.now(timezone.utc) > state.expires_at:
+                    ids.append(id)
             for id in ids:
                 logger.info(f"Delete expired oauth state: {id}")
                 self.retrieve_state(id)
 
     def delete_temp_dirs(self):
-        for temp_dir in self.__temp_dirs.keys():
+        for temp_dir in self.__temp_dirs:
             logger.info(f"Deleting temp dir: {temp_dir}")
             shutil.rmtree(temp_dir, ignore_errors=True)
 

flet_web/fastapi/flet_oauth.py

@@ -1,5 +1,6 @@
 from fastapi import HTTPException, Request
 from fastapi.responses import HTMLResponse, RedirectResponse
+
 from flet_web.fastapi.flet_app_manager import app_manager
 
 
@@ -33,7 +34,7 @@ class FletOAuth:
         if not session:
             raise HTTPException(status_code=500, detail="Session not found")
 
-        await session._authorize_callback_async(
+        await session.page._authorize_callback_async(
             {
                 "state": state_id,
                 "code": request.query_params.get("code"),

flet_web/fastapi/flet_static_files.py

@@ -3,16 +3,22 @@ import os
 import shutil
 import tempfile
 from pathlib import Path
-from typing import Optional, Tuple
+from typing import Optional
 
-import flet_web.fastapi as flet_fastapi
 from fastapi.staticfiles import StaticFiles
-from flet.core.types import WebRenderer
+from flet.controls.types import RouteUrlStrategy, WebRenderer
 from flet.utils import Once, get_bool_env_var
-from flet_web import get_package_web_dir, patch_index_html, patch_manifest_json
-from flet_web.fastapi.flet_app_manager import app_manager
 from starlette.types import Receive, Scope, Send
 
+import flet_web.fastapi as flet_fastapi
+from flet_web import (
+    get_package_web_dir,
+    patch_font_manifest_json,
+    patch_index_html,
+    patch_manifest_json,
+)
+from flet_web.fastapi.flet_app_manager import app_manager
+
 logger = logging.getLogger(flet_fastapi.__name__)
 
 
@@ -27,10 +33,11 @@ class FletStaticFiles(StaticFiles):
     * `app_name` (str, optional) - PWA application name.
     * `app_short_name` (str, optional) - PWA application short name.
     * `app_description` (str, optional) - PWA application description.
-    * `web_renderer` (WebRenderer) - web renderer defaulting to `WebRenderer.CANVAS_KIT`.
-    * `use_color_emoji` (bool) - whether to load a font with color emoji. Default is `False`.
+    * `web_renderer` (WebRenderer) - web renderer defaulting to `WebRenderer.AUTO`.
     * `route_url_strategy` (str) - routing URL strategy: `path` (default) or `hash`.
-    * `websocket_endpoint_path` (str, optional) - absolute URL of Flet app WebSocket handler. Default is `{app_mount_path}/ws`.
+    * `no_cdn` - do not load CanvasKit, Pyodide and fonts from CDN
+    * `websocket_endpoint_path` (str, optional) - absolute URL of Flet app
+       WebSocket handler. Default is `{app_mount_path}/ws`.
     """
 
     def __init__(
@@ -40,21 +47,22 @@ class FletStaticFiles(StaticFiles):
         app_name: Optional[str] = None,
         app_short_name: Optional[str] = None,
         app_description: Optional[str] = None,
-        web_renderer: WebRenderer = WebRenderer.CANVAS_KIT,
-        use_color_emoji: bool = False,
-        route_url_strategy: str = "path",
+        web_renderer: WebRenderer = WebRenderer.AUTO,
+        route_url_strategy: RouteUrlStrategy = RouteUrlStrategy.PATH,
+        no_cdn: bool = False,
         websocket_endpoint_path: Optional[str] = None,
     ) -> None:
-        self.index = "index.html"
-        self.manifest_json = "manifest.json"
+        self.index = ["index.html"]
+        self.manifest_json = ["manifest.json"]
+        self.font_manifest_json = ["assets", "FontManifest.json"]
         self.__proxy_path = proxy_path
         self.__assets_dir = assets_dir
         self.__app_name = app_name
         self.__app_short_name = app_short_name
         self.__app_description = app_description
         self.__web_renderer = web_renderer
-        self.__use_color_emoji = use_color_emoji
         self.__route_url_strategy = route_url_strategy
+        self.__no_cdn = no_cdn
         self.__websocket_endpoint_path = websocket_endpoint_path
         self.__once = Once()
 
@@ -62,23 +70,23 @@ class FletStaticFiles(StaticFiles):
         if env_web_renderer:
             self.__web_renderer = WebRenderer(env_web_renderer)
 
-        env_use_color_emoji = get_bool_env_var("FLET_WEB_USE_COLOR_EMOJI")
-        if env_use_color_emoji is not None:
-            self.__use_color_emoji = env_use_color_emoji
-
         env_route_url_strategy = os.getenv("FLET_WEB_ROUTE_URL_STRATEGY")
         if env_route_url_strategy:
-            self.__route_url_strategy = env_route_url_strategy
+            self.__route_url_strategy = RouteUrlStrategy(env_route_url_strategy)
+
+        env_no_cdn = get_bool_env_var("FLET_WEB_NO_CDN")
+        if env_no_cdn is not None:
+            self.__no_cdn = env_no_cdn
 
         logger.info(f"Web renderer configured: {self.__web_renderer}")
-        logger.info(f"Use color emoji: {self.__use_color_emoji}")
         logger.info(f"Route URL strategy configured: {self.__route_url_strategy}")
+        logger.info(f"No CDN configured: {self.__no_cdn}")
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         await self.__once.do(self.__config, scope["root_path"])
         await super().__call__(scope, receive, send)
 
-    def lookup_path(self, path: str) -> Tuple[str, Optional[os.stat_result]]:
+    def lookup_path(self, path: str) -> tuple[str, Optional[os.stat_result]]:
         """Returns the index file when no match is found.
 
         Args:
@@ -92,7 +100,7 @@ class FletStaticFiles(StaticFiles):
 
         # if a file cannot be found
         if stat_result is None:
-            return super().lookup_path(self.index)
+            return super().lookup_path(self.index[0])
 
         return full_path, stat_result
 
@@ -125,33 +133,22 @@ class FletStaticFiles(StaticFiles):
 
         logger.info(f"Assets dir: {self.__assets_dir}")
 
+        def copy_temp_web_file(paths: list[str]):
+            if self.__assets_dir and os.path.exists(
+                p := os.path.join(self.__assets_dir, *paths)
+            ):
+                src_path = p
+            else:
+                src_path = os.path.join(web_dir, *paths)
+            dst_path = os.path.join(temp_dir, *paths)
+            Path(dst_path).parent.mkdir(parents=True, exist_ok=True)
+            shutil.copyfile(src_path, dst_path)
+
         # copy index.html from assets_dir or web_dir
-        if self.__assets_dir and os.path.exists(
-            os.path.join(self.__assets_dir, self.index)
-        ):
-            shutil.copyfile(
-                os.path.join(self.__assets_dir, self.index),
-                os.path.join(temp_dir, self.index),
-            )
-        else:
-            shutil.copyfile(
-                os.path.join(web_dir, self.index),
-                os.path.join(temp_dir, self.index),
-            )
+        copy_temp_web_file(self.index)
 
         # copy manifest.json from assets_dir or web_dir
-        if self.__assets_dir and os.path.exists(
-            os.path.join(self.__assets_dir, self.manifest_json)
-        ):
-            shutil.copyfile(
-                os.path.join(self.__assets_dir, self.manifest_json),
-                os.path.join(temp_dir, self.manifest_json),
-            )
-        else:
-            shutil.copyfile(
-                os.path.join(web_dir, self.manifest_json),
-                os.path.join(temp_dir, self.manifest_json),
-            )
+        copy_temp_web_file(self.manifest_json)
 
         ws_path = self.__websocket_endpoint_path
         if not ws_path:
@@ -160,23 +157,30 @@ class FletStaticFiles(StaticFiles):
 
         # replace variables in index.html and manifest.json
         patch_index_html(
-            index_path=os.path.join(temp_dir, self.index),
+            index_path=os.path.join(temp_dir, *self.index),
             base_href=self.__app_mount_path,
             websocket_endpoint_path=ws_path,
             app_name=self.__app_name,
             app_description=self.__app_description,
-            web_renderer=WebRenderer(self.__web_renderer),
-            use_color_emoji=self.__use_color_emoji,
+            web_renderer=self.__web_renderer,
             route_url_strategy=self.__route_url_strategy,
+            no_cdn=self.__no_cdn,
         )
 
         patch_manifest_json(
-            manifest_path=os.path.join(temp_dir, self.manifest_json),
+            manifest_path=os.path.join(temp_dir, *self.manifest_json),
             app_name=self.__app_name,
             app_short_name=self.__app_short_name,
             app_description=self.__app_description,
         )
 
+        if self.__no_cdn:
+            # copy FontManifest.json from assets_dir or web_dir
+            copy_temp_web_file(self.font_manifest_json)
+            patch_font_manifest_json(
+                manifest_path=os.path.join(temp_dir, *self.font_manifest_json)
+            )
+
         # set html=True to resolve the index even when no
         # the base path is passed in
         super().__init__(directory=temp_dir, packages=None, html=True, check_dir=True)

flet_web/fastapi/serve_fastapi_web_app.py

@@ -1,9 +1,9 @@
 import asyncio
 import logging
-from typing import Optional
+from typing import Any, Optional, Union
 
 import uvicorn
-from flet.core.types import WebRenderer
+from flet.controls.types import RouteUrlStrategy, WebRenderer
 
 import flet_web.fastapi
 import flet_web.fastapi as flet_fastapi
@@ -22,25 +22,27 @@ class WebServerHandle:
 
 
 def get_fastapi_web_app(
-    session_handler,
+    main,
+    before_main,
     page_name: str,
-    assets_dir,
-    upload_dir,
-    web_renderer: Optional[WebRenderer],
-    use_color_emoji,
-    route_url_strategy,
+    assets_dir: str,
+    upload_dir: str,
+    web_renderer: WebRenderer = WebRenderer.AUTO,
+    route_url_strategy: RouteUrlStrategy = RouteUrlStrategy.PATH,
+    no_cdn: bool = False,
 ):
     web_path = f"/{page_name.strip('/')}"
     app = flet_web.fastapi.FastAPI()
     app.mount(
         web_path,
         flet_web.fastapi.app(
-            session_handler,
+            main,
+            before_main=before_main,
             upload_dir=upload_dir,
             assets_dir=assets_dir,
-            web_renderer=web_renderer if web_renderer else WebRenderer.AUTO,
-            use_color_emoji=use_color_emoji,
+            web_renderer=web_renderer,
             route_url_strategy=route_url_strategy,
+            no_cdn=no_cdn,
         ),
     )
 
@@ -48,21 +50,21 @@ def get_fastapi_web_app(
 
 
 async def serve_fastapi_web_app(
-    session_handler,
-    host,
-    url_host,
-    port,
+    main,
+    before_main,
+    host: str,
+    url_host: str,
+    port: int,
     page_name: str,
-    assets_dir,
-    upload_dir,
-    web_renderer: Optional[WebRenderer],
-    use_color_emoji,
-    route_url_strategy,
-    blocking,
-    on_startup,
-    log_level,
+    assets_dir: str,
+    upload_dir: str,
+    web_renderer: WebRenderer = WebRenderer.AUTO,
+    route_url_strategy: RouteUrlStrategy = RouteUrlStrategy.PATH,
+    no_cdn: bool = False,
+    blocking: bool = False,
+    on_startup: Optional[Any] = None,
+    log_level: Optional[Union[str, int]] = None,
 ):
-
     web_path = f"/{page_name.strip('/')}"
     page_url = f"http://{url_host}:{port}{web_path if web_path != '/' else ''}"
 
@@ -75,12 +77,13 @@ async def serve_fastapi_web_app(
     app.mount(
         web_path,
         flet_web.fastapi.app(
-            session_handler,
+            main,
+            before_main=before_main,
             upload_dir=upload_dir,
             assets_dir=assets_dir,
-            web_renderer=web_renderer if web_renderer else WebRenderer.AUTO,
-            use_color_emoji=use_color_emoji,
+            web_renderer=web_renderer,
             route_url_strategy=route_url_strategy,
+            no_cdn=no_cdn,
         ),
     )
     config = uvicorn.Config(app, host=host, port=port, log_level=log_level)

flet_web/patch_index.py

@@ -3,7 +3,7 @@ import re
 from pathlib import Path
 from typing import Optional
 
-from flet.core.types import WebRenderer
+from flet.controls.types import RouteUrlStrategy, WebRenderer
 
 
 def patch_index_html(
@@ -16,64 +16,54 @@ def patch_index_html(
     pyodide_pre: bool = False,
     pyodide_script_path: str = "",
     web_renderer: WebRenderer = WebRenderer.AUTO,
-    use_color_emoji: bool = False,
-    route_url_strategy: str = "path",
+    route_url_strategy: RouteUrlStrategy = RouteUrlStrategy.PATH,
+    no_cdn: bool = False,
 ):
-    with open(index_path, "r", encoding="utf-8") as f:
+    with open(index_path, encoding="utf-8") as f:
         index = f.read()
 
+    app_config = []
+
     if pyodide and pyodide_script_path:
         module_name = Path(pyodide_script_path).stem
-        pyodideCode = f"""
-        <script>
-            var micropipIncludePre = {str(pyodide_pre).lower()};
-            var pythonModuleName = "{module_name}";
-        </script>
-        <script src="python.js"></script>
-        """
-        index = index.replace("<!-- pyodideCode -->", pyodideCode)
-    index = index.replace("%FLET_WEB_PYODIDE%", str(pyodide).lower())
-    index = index.replace(
-        "<!-- webRenderer -->",
-        f'<script>webRenderer="{web_renderer.value}";</script>',
-    )
+        app_config.append("flet.pyodide = true;")
+        app_config.append(f"flet.micropipIncludePre = {str(pyodide_pre).lower()};")
+        app_config.append(f'flet.pythonModuleName = "{module_name}";')
+
+    app_config.append(f"flet.noCdn={str(no_cdn).lower()};")
+    app_config.append(f'flet.webRenderer="{web_renderer.value}";')
+    app_config.append(f'flet.routeUrlStrategy="{route_url_strategy.value}";')
+
+    if websocket_endpoint_path:
+        app_config.append(f'flet.webSocketEndpoint="{websocket_endpoint_path}";')
+
     index = index.replace(
-        "<!-- useColorEmoji -->",
-        f"<script>useColorEmoji={str(use_color_emoji).lower()};</script>",
+        "<!-- fletAppConfig -->",
+        "<script>\n{}\n</script>".format("\n".join(app_config)),
     )
-    index = index.replace("%FLET_ROUTE_URL_STRATEGY%", route_url_strategy)
 
     if base_href:
         base_url = base_href.strip("/").strip()
         index = index.replace(
             '<base href="/">',
-            '<base href="{}">'.format(
-                "/" if base_url == "" else "/{}/".format(base_url)
-            ),
-        )
-    if websocket_endpoint_path:
-        index = re.sub(
-            r"\<meta name=\"flet-websocket-endpoint-path\" content=\"(.+)\">",
-            r'<meta name="flet-websocket-endpoint-path" content="{}">'.format(
-                websocket_endpoint_path
-            ),
-            index,
+            '<base href="{}">'.format("/" if base_url == "" else f"/{base_url}/"),
         )
+
     if app_name:
         index = re.sub(
             r"\<meta name=\"apple-mobile-web-app-title\" content=\"(.+)\">",
-            r'<meta name="apple-mobile-web-app-title" content="{}">'.format(app_name),
+            rf'<meta name="apple-mobile-web-app-title" content="{app_name}">',
             index,
         )
         index = re.sub(
             r"\<title>(.+)</title>",
-            r"<title>{}</title>".format(app_name),
+            rf"<title>{app_name}</title>",
             index,
         )
     if app_description:
         index = re.sub(
             r"\<meta name=\"description\" content=\"(.+)\">",
-            r'<meta name="description" content="{}">'.format(app_description),
+            rf'<meta name="description" content="{app_description}">',
             index,
         )
 
@@ -89,7 +79,7 @@ def patch_manifest_json(
     background_color: Optional[str] = None,
     theme_color: Optional[str] = None,
 ):
-    with open(manifest_path, "r", encoding="utf-8") as f:
+    with open(manifest_path, encoding="utf-8") as f:
         manifest = json.loads(f.read())
 
     if app_name:
@@ -110,3 +100,13 @@ def patch_manifest_json(
 
     with open(manifest_path, "w", encoding="utf-8") as f:
         f.write(json.dumps(manifest, indent=2))
+
+
+def patch_font_manifest_json(manifest_path: str):
+    with open(manifest_path, encoding="utf-8") as f:
+        manifest = json.loads(f.read())
+
+    manifest.append({"family": "Roboto", "fonts": [{"asset": "fonts/roboto.woff2"}]})
+
+    with open(manifest_path, "w", encoding="utf-8") as f:
+        f.write(json.dumps(manifest, indent=2))

flet_web/version.py

@@ -1 +1 @@
-version = "0.29.0.dev5039"
+version = "0.70.0.dev5066"