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

flet_web/fastapi/flet_app.py

@@ -1,42 +1,52 @@
 import asyncio
-import copy
-import json
+import inspect
 import logging
 import os
 import traceback
+import weakref
+from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
-import flet_web.fastapi as flet_fastapi
+import msgpack
 from fastapi import WebSocket, WebSocketDisconnect
-from flet.core.event import Event
-from flet.core.local_connection import LocalConnection
-from flet.core.page import Page, PageDisconnectedException
-from flet.core.protocol import (
-    ClientActions,
+from flet.controls.base_control import BaseControl
+from flet.controls.page import PageDisconnectedException, _session_page
+from flet.controls.update_behavior import UpdateBehavior
+from flet.messaging.connection import Connection
+from flet.messaging.protocol import (
+    ClientAction,
     ClientMessage,
-    Command,
-    CommandEncoder,
-    PageCommandResponsePayload,
-    PageCommandsBatchResponsePayload,
-    RegisterWebClientRequestPayload,
+    ControlEventBody,
+    InvokeMethodResponseBody,
+    RegisterClientRequestBody,
+    RegisterClientResponseBody,
+    UpdateControlPropsBody,
+    configure_encode_object_for_msgpack,
+    decode_ext_from_msgpack,
 )
+from flet.messaging.session import Session
 from flet.utils import random_string, sha1
+
+import flet_web.fastapi as flet_fastapi
 from flet_web.fastapi.flet_app_manager import app_manager
 from flet_web.fastapi.oauth_state import OAuthState
 from flet_web.uploads import build_upload_url
 
 logger = logging.getLogger(flet_fastapi.__name__)
+transport_log = logging.getLogger("flet_transport")
 
 DEFAULT_FLET_SESSION_TIMEOUT = 3600
 DEFAULT_FLET_OAUTH_STATE_TIMEOUT = 600
 
 
-class FletApp(LocalConnection):
+class FletApp(Connection):
     def __init__(
         self,
         loop: asyncio.AbstractEventLoop,
-        session_handler,
+        executor: ThreadPoolExecutor,
+        main,
+        before_main,
         session_timeout_seconds: int = DEFAULT_FLET_SESSION_TIMEOUT,
         oauth_state_timeout_seconds: int = DEFAULT_FLET_OAUTH_STATE_TIMEOUT,
         upload_endpoint_path: Optional[str] = None,
@@ -47,21 +57,30 @@ class FletApp(LocalConnection):
 
         Parameters:
 
-        * `session_handler` (Coroutine) - application entry point - an async method called for newly connected user. Handler coroutine must have 1 parameter: `page` - `Page` instance.
-        * `session_timeout_seconds` (int, optional) - session lifetime, in seconds, after user disconnected.
-        * `oauth_state_timeout_seconds` (int, optional) - OAuth state lifetime, in seconds, which is a maximum allowed time between starting OAuth flow and redirecting to OAuth callback URL.
-        * `upload_endpoint_path` (str, optional) - absolute URL of upload endpoint, e.g. `/upload`.
+        * `session_handler` (Coroutine) - application entry point - an async method
+           called for newly connected user. Handler coroutine must have
+           1 parameter: `page` - `Page` instance.
+        * `session_timeout_seconds` (int, optional) - session lifetime, in seconds,
+           after user disconnected.
+        * `oauth_state_timeout_seconds` (int, optional) - OAuth state lifetime,
+           in seconds, which is a maximum allowed time between starting OAuth flow
+           and redirecting to OAuth callback URL.
+        * `upload_endpoint_path` (str, optional) - absolute URL of upload endpoint,
+           e.g. `/upload`.
         * `secret_key` (str, optional) - secret key to sign upload requests.
         """
         super().__init__()
         self.__id = random_string(8)
         logger.info(f"New FletApp: {self.__id}")
 
-        self.__page = None
-        self.__loop = loop
-        self.__session_handler = session_handler
+        self.__session = None
+        self.loop = loop
+        self.executor = executor
+        self.__main = main
+        self.__before_main = before_main
         self.__session_timeout_seconds = session_timeout_seconds
         self.__oauth_state_timeout_seconds = oauth_state_timeout_seconds
+        self.__running_tasks = set()
 
         env_session_timeout_seconds = os.getenv("FLET_SESSION_TIMEOUT")
         if env_session_timeout_seconds:
@@ -74,6 +93,11 @@ class FletApp(LocalConnection):
         self.__upload_endpoint_path = upload_endpoint_path
         self.__secret_key = secret_key
 
+        app_id = self.__id
+        weakref.finalize(
+            self, lambda: logger.debug(f"FletApp was garbage collected: {app_id}")
+        )
+
     async def handle(self, websocket: WebSocket):
         """
         Handle WebSocket connection.
@@ -87,15 +111,9 @@ class FletApp(LocalConnection):
         self.client_ip = (
             self.__websocket.client.host if self.__websocket.client else ""
         ).split(":")[0]
-        self.client_user_agent = (
-            self.__websocket.headers["user-agent"]
-            if "user-agent" in self.__websocket.headers
-            else ""
-        )
+        self.client_user_agent = self.__websocket.headers.get("user-agent", "")
 
-        self.pubsubhub = app_manager.get_pubsubhub(
-            self.__session_handler, loop=self.__loop
-        )
+        self.pubsubhub = app_manager.get_pubsubhub(self.__main, loop=self.loop)
         self.page_url = str(websocket.url).rsplit("/", 1)[0]
         self.page_name = websocket.url.path.rsplit("/", 1)[0].lstrip("/")
 
@@ -106,320 +124,209 @@ class FletApp(LocalConnection):
 
         await self.__websocket.accept()
         self.__send_queue = asyncio.Queue()
-        st = asyncio.create_task(self.__send_loop())
+        send_loop_task = asyncio.create_task(self.__send_loop())
         await self.__receive_loop()
-        st.cancel()
+        await send_loop_task
 
-    async def __on_event(self, e):
-        session = await app_manager.get_session(
-            self.__get_unique_session_id(e.sessionID)
+        # disconnect this connection from a session
+        await app_manager.disconnect_session(
+            self.__get_unique_session_id(self.__session.id),
+            self.__session_timeout_seconds,
         )
-        if session is not None:
-            try:
-                await session.on_event_async(
-                    Event(e.eventTarget, e.eventName, e.eventData)
-                )
-            except PageDisconnectedException:
-                logger.debug(
-                    f"Event handler attempted to update disconnected page: {e.sessionID}"
-                )
-            if e.eventTarget == "page" and e.eventName == "close":
-                logger.info(f"Session closed: {e.sessionID}")
-                await app_manager.delete_session(
-                    self.__get_unique_session_id(e.sessionID)
-                )
 
-    async def __on_session_created(self, session_data):
-        logger.info(f"Start session: {session_data.sessionID}")
-        session_id = session_data.sessionID
+    async def __on_session_created(self):
+        assert self.__session
+        logger.info(f"Start session: {self.__session.id}")
         try:
-            assert self.__session_handler is not None
-            if asyncio.iscoroutinefunction(self.__session_handler):
-                await self.__session_handler(self.__page)
+            assert self.__main is not None
+            _session_page.set(self.__session.page)
+            UpdateBehavior.reset()
+
+            if asyncio.iscoroutinefunction(self.__main):
+                await self.__main(self.__session.page)
+
+            elif inspect.isasyncgenfunction(self.__main):
+                async for _ in self.__main(self.__session.page):
+                    if UpdateBehavior.auto_update_enabled():
+                        await self.__session.auto_update(self.__session.page)
+
+            elif inspect.isgeneratorfunction(self.__main):
+                for _ in self.__main(self.__session.page):
+                    if UpdateBehavior.auto_update_enabled():
+                        await self.__session.auto_update(self.__session.page)
             else:
-                # run in thread pool
-                await asyncio.get_running_loop().run_in_executor(
-                    app_manager.executor, self.__session_handler, self.__page
-                )
+                self.__main(self.__session.page)
+
+            if UpdateBehavior.auto_update_enabled():
+                await self.__session.auto_update(self.__session.page)
         except PageDisconnectedException:
             logger.debug(
-                f"Session handler attempted to update disconnected page: {session_id}"
+                "Session handler attempted to update disconnected page: "
+                f"{self.__session.id}"
             )
         except BrokenPipeError:
-            logger.info(f"Session handler terminated: {session_id}")
+            logger.info(f"Session handler terminated: {self.__session.id}")
         except Exception as e:
             print(
-                f"Unhandled error processing page session {session_id}:",
+                f"Unhandled error processing page session {self.__session.id}:",
                 traceback.format_exc(),
             )
-            assert self.__page
-            self.__page.error(f"There was an error while processing your request: {e}")
+            assert self.__session
+            self.__session.error(
+                f"There was an error while processing your request: {e}"
+            )
 
     async def __send_loop(self):
         assert self.__websocket
         assert self.__send_queue
         while True:
             message = await self.__send_queue.get()
+            if message is None:
+                break
+
             try:
-                await self.__websocket.send_text(message)
+                await self.__websocket.send_bytes(message)
             except Exception:
                 # re-enqueue the message to repeat it when re-connected
-                self.__send_queue.put_nowait(message)
+                # self.__send_queue.put_nowait(message)
                 raise
+        self.__websocket = None
+        self.__send_queue = None
 
     async def __receive_loop(self):
         assert self.__websocket
         try:
             while True:
-                await self.__on_message(await self.__websocket.receive_text())
+                data = await self.__websocket.receive_bytes()
+                await self.__on_message(
+                    msgpack.unpackb(data, ext_hook=decode_ext_from_msgpack)
+                )
         except Exception as e:
             if not isinstance(e, WebSocketDisconnect):
-                logger.warning(f"Receive loop error: {e}")
-            if self.__page:
-                await app_manager.disconnect_session(
-                    self.__get_unique_session_id(self.__page.session_id),
-                    self.__session_timeout_seconds,
+                logger.warning(f"Receive loop error: {e}", exc_info=True)
+            if self.__session:
+                # terminate __send_loop
+                await self.__send_queue.put(None)
+
+    async def __on_message(self, data: Any):
+        action = ClientAction(data[0])
+        body = data[1]
+        transport_log.debug(f"_on_message: {action} {body}")
+        task = None
+        if action == ClientAction.REGISTER_CLIENT:
+            req = RegisterClientRequestBody(**body)
+
+            new_session = False
+
+            # try to retrieve existing session
+            if req.session_id:
+                self.__session = await app_manager.get_session(
+                    self.__get_unique_session_id(req.session_id)
                 )
-        self.__websocket = None
-        self.__send_queue = None
 
-    async def __on_message(self, data: str):
-        logger.debug(f"_on_message: {data}")
-        msg_dict = json.loads(data)
-        msg = ClientMessage(**msg_dict)
-        if msg.action == ClientActions.REGISTER_WEB_CLIENT:
-            self._client_details = RegisterWebClientRequestPayload(**msg.payload)
-
-            new_session = True
-            if (
-                not self._client_details.sessionId
-                or await app_manager.get_session(
-                    self.__get_unique_session_id(self._client_details.sessionId)
-                )
-                is None
-            ):
-                # generate session ID
-                self._client_details.sessionId = random_string(16)
-
-                # create new Page object
-                self.__page = Page(
-                    self,
-                    self._client_details.sessionId,
-                    executor=app_manager.executor,
-                    loop=asyncio.get_running_loop(),
-                )
+            # re-create session
+            if self.__session is None:
+                new_session = True
+
+                # create new session
+                self.__session = Session(self)
 
                 # register session
                 await app_manager.add_session(
-                    self.__get_unique_session_id(self._client_details.sessionId),
-                    self.__page,
-                )
-            else:
-                # existing session
-                logger.info(
-                    f"Existing session requested: {self._client_details.sessionId}"
+                    self.__get_unique_session_id(self.__session.id),
+                    self.__session,
                 )
-                self.__page = await app_manager.get_session(
-                    self.__get_unique_session_id(self._client_details.sessionId)
+
+            original_route = self.__session.page.route
+
+            # apply page patch
+            self.__session.apply_page_patch(req.page)
+
+            if new_session:
+                if asyncio.iscoroutinefunction(self.__before_main):
+                    await self.__before_main(self.__session.page)
+                elif callable(self.__before_main):
+                    self.__before_main(self.__session.page)
+
+            # register response
+            self.send_message(
+                ClientMessage(
+                    ClientAction.REGISTER_CLIENT,
+                    RegisterClientResponseBody(
+                        session_id=self.__session.id,
+                        page_patch=self.__session.get_page_patch(),
+                        error="",
+                    ),
                 )
-                new_session = False
-
-            # update page props
-            assert self.__page
-            original_route = self.__page.route
-            self.__page._set_attr("route", self._client_details.pageRoute, False)
-            self.__page._set_attr("pwa", self._client_details.isPWA, False)
-            self.__page._set_attr("web", self._client_details.isWeb, False)
-            self.__page._set_attr("debug", self._client_details.isDebug, False)
-            self.__page._set_attr("platform", self._client_details.platform, False)
-            self.__page._set_attr(
-                "platformBrightness", self._client_details.platformBrightness, False
-            )
-            self.__page._set_attr("media", self._client_details.media, False)
-            self.__page._set_attr("width", self._client_details.pageWidth, False)
-            self.__page._set_attr("height", self._client_details.pageHeight, False)
-            self.__page._set_attr(
-                "windowWidth", self._client_details.windowWidth, False
-            )
-            self.__page._set_attr(
-                "windowHeight", self._client_details.windowHeight, False
-            )
-            self.__page._set_attr("windowTop", self._client_details.windowTop, False)
-            self.__page._set_attr("windowLeft", self._client_details.windowLeft, False)
-            self.__page._set_attr("clientIP", self.client_ip, False)
-            self.__page._set_attr("clientUserAgent", self.client_user_agent, False)
-
-            p = self.__page.snapshot.get("page")
-            if not p:
-                p = {
-                    "i": "page",
-                    "t": "page",
-                    "p": "",
-                    "c": [],
-                }
-                self.__page.snapshot["page"] = p
-            self.__page.copy_attrs(p)
-
-            # send register response
-            self.__send(
-                self._create_register_web_client_response(controls=self.__page.snapshot)
             )
 
             # start session
             if new_session:
-                asyncio.create_task(
-                    self.__on_session_created(self._create_session_handler_arg())
-                )
+                asyncio.create_task(self.__on_session_created())
             else:
                 await app_manager.reconnect_session(
-                    self.__get_unique_session_id(self._client_details.sessionId), self
+                    self.__get_unique_session_id(self.__session.id), self
                 )
 
-                if original_route != self.__page.route:
-                    self.__page.go(self.__page.route)
+                if (
+                    self.__session.page.route
+                    and self.__session.page.route != original_route
+                ):
+                    self.__session.page.go(self.__session.page.route)
 
-        elif msg.action == ClientActions.PAGE_EVENT_FROM_WEB:
-            if self.__on_event is not None:
-                asyncio.create_task(
-                    self.__on_event(self._create_page_event_handler_arg(msg))
-                )
+        elif action == ClientAction.CONTROL_EVENT:
+            req = ControlEventBody(**body)
+            task = asyncio.create_task(
+                self.__session.dispatch_event(req.target, req.name, req.data)
+            )
+
+        elif action == ClientAction.UPDATE_CONTROL_PROPS:
+            req = UpdateControlPropsBody(**body)
+            self.__session.apply_patch(req.id, req.props)
+
+        elif action == ClientAction.INVOKE_METHOD:
+            req = InvokeMethodResponseBody(**body)
+            self.__session.handle_invoke_method_results(
+                req.control_id, req.call_id, req.result, req.error
+            )
 
-        elif msg.action == ClientActions.UPDATE_CONTROL_PROPS:
-            if self.__on_event is not None:
-                asyncio.create_task(
-                    self.__on_event(self._create_update_control_props_handler_arg(msg))
-                )
         else:
             # it's something else
-            raise Exception(f'Unknown message "{msg.action}": {msg.payload}')
-
-    def _process_get_upload_url_command(self, attrs):
-        assert len(attrs) == 2, '"getUploadUrl" command has wrong number of attrs'
-        assert (
-            self.__upload_endpoint_path
-        ), "upload_path should be specified to enable uploads"
-        return (
-            build_upload_url(
-                self.__upload_endpoint_path,
-                attrs["file"],
-                int(attrs["expires"]),
-                self.__secret_key,
-            ),
-            None,
+            raise Exception(f'Unknown message "{action}": {body}')
+
+        if task:
+            self.__running_tasks.add(task)
+            task.add_done_callback(self.__running_tasks.discard)
+
+    def send_message(self, message: ClientMessage):
+        transport_log.debug(f"send_message: {message}")
+        m = msgpack.packb(
+            [message.action, message.body],
+            default=configure_encode_object_for_msgpack(BaseControl),
+        )
+        self.__send_queue.put_nowait(m)
+
+    def get_upload_url(self, file_name: str, expires: int) -> str:
+        assert self.__upload_endpoint_path, (
+            "upload_path should be specified to enable uploads"
+        )
+        return build_upload_url(
+            self.__upload_endpoint_path,
+            file_name,
+            expires,
+            self.__secret_key,
         )
 
-    def __process_oauth_authorize_command(self, attrs: Dict[str, Any]):
+    def oauth_authorize(self, attrs: dict[str, Any]):
         state_id = attrs["state"]
         state = OAuthState(
-            session_id=self.__get_unique_session_id(self._client_details.sessionId),
+            session_id=self.__get_unique_session_id(self.__session.id),
             expires_at=datetime.now(timezone.utc)
             + timedelta(seconds=self.__oauth_state_timeout_seconds),
-            complete_page_html=attrs.get("completePageHtml", None),
-            complete_page_url=attrs.get("completePageUrl", None),
+            complete_page_html=attrs.get("completePageHtml"),
+            complete_page_url=attrs.get("completePageUrl"),
         )
         app_manager.store_state(state_id, state)
-        return (
-            "",
-            None,
-        )
-
-    def _process_add_command(self, command: Command):
-        assert self.__page
-        result, message = super()._process_add_command(command)
-        if message:
-            for oc in message.payload.controls:
-                control = copy.deepcopy(oc)
-                id = control["i"]
-                pid = control["p"]
-                parent = self.__page.snapshot[pid]
-                assert parent, f"parent control not found: {pid}"
-                if id not in parent["c"]:
-                    if "at" in control:
-                        parent["c"].insert(int(control["at"]), id)
-                    else:
-                        parent["c"].append(id)
-                self.__page.snapshot[id] = control
-        return result, message
-
-    def _process_set_command(self, values, attrs):
-        assert self.__page
-        result, message = super()._process_set_command(values, attrs)
-        control = self.__page.snapshot.get(values[0])
-        if control:
-            for k, v in attrs.items():
-                control[k] = v
-        return result, message
-
-    def _process_remove_command(self, values):
-        assert self.__page
-        result, message = super()._process_remove_command(values)
-        for id in values:
-            control = self.__page.snapshot.get(id)
-            assert (
-                control is not None
-            ), f"_process_remove_command: control with ID '{id}' not found."
-            for cid in self.__get_all_descendant_ids(id):
-                self.__page.snapshot.pop(cid, None)
-            # delete control itself
-            self.__page.snapshot.pop(id, None)
-            # remove id from parent
-            parent = self.__page.snapshot.get(control["p"])
-            if parent:
-                parent["c"].remove(id)
-        return result, message
-
-    def _process_clean_command(self, values):
-        assert self.__page
-        result, message = super()._process_clean_command(values)
-        for id in values:
-            for cid in self.__get_all_descendant_ids(id):
-                self.__page.snapshot.pop(cid, None)
-        return result, message
-
-    def __get_all_descendant_ids(self, id):
-        assert self.__page
-        ids = []
-        control = self.__page.snapshot.get(id)
-        if control:
-            for cid in control["c"]:
-                ids.append(cid)
-                ids.extend(self.__get_all_descendant_ids(cid))
-        return ids
-
-    def send_command(self, session_id: str, command: Command):
-        if command.name == "oauthAuthorize":
-            result, message = self.__process_oauth_authorize_command(command.attrs)
-        else:
-            result, message = self._process_command(command)
-        if message:
-            self.__send(message)
-        return PageCommandResponsePayload(result=result, error="")
-
-    def send_commands(self, session_id: str, commands: List[Command]):
-        results = []
-        messages = []
-        for command in commands:
-            if command.name == "oauthAuthorize":
-                result, message = self.__process_oauth_authorize_command(command.attrs)
-            else:
-                result, message = self._process_command(command)
-            if command.name in ["add", "get"]:
-                results.append(result)
-            if message:
-                messages.append(message)
-        if len(messages) > 0:
-            self.__send(ClientMessage(ClientActions.PAGE_CONTROLS_BATCH, messages))
-        return PageCommandsBatchResponsePayload(results=results, error="")
-
-    def __send(self, message: ClientMessage):
-        m = json.dumps(message, cls=CommandEncoder, separators=(",", ":"))
-        logger.debug(f"__send: {m}")
-        if self.__send_queue:
-            self.__loop.call_soon_threadsafe(self.__send_queue.put_nowait, m)
-
-    def _get_next_control_id(self):
-        assert self.__page
-        return self.__page.get_next_control_id()
 
     def __get_unique_session_id(self, session_id: str):
         client_hash = sha1(f"{self.client_ip}{self.client_user_agent}")
@@ -427,4 +334,4 @@ class FletApp(LocalConnection):
 
     def dispose(self):
         logger.info(f"Disposing FletApp: {self.__id}")
-        self.__page = None
+        self.__session = None