flet-web 0.70.0.dev6516__py3-none-any.whl → 0.70.0.dev6616__py3-none-any.whl

flet_web/fastapi/flet_app.py

@@ -168,15 +168,13 @@ class FletApp(Connection):
                 f"{self.__session.id if self.__session else ''}"
             )
         except Exception as e:
-            print(
+            logger.error(
                 "Unhandled error processing page session: "
                 f"{self.__session.id if self.__session else ''}",
-                traceback.format_exc(),
+                exc_info=True,
             )
             if self.__session:
-                self.__session.error(
-                    f"There was an error while processing your request: {e}"
-                )
+                self.__session.error(str(e))
 
     async def __send_loop(self):
         assert self.__websocket
@@ -254,16 +252,23 @@ class FletApp(Connection):
             # apply page patch
             self.__session.apply_page_patch(req.page)
 
+            register_error = ""
             if new_session:
                 # update IP and user-agent
                 self.__session.page.client_ip = self.__client_ip
                 self.__session.page.client_user_agent = self.__client_user_agent
 
                 # run before_main
-                if asyncio.iscoroutinefunction(self.__before_main):
-                    await self.__before_main(self.__session.page)
-                elif callable(self.__before_main):
-                    self.__before_main(self.__session.page)
+                try:
+                    if asyncio.iscoroutinefunction(self.__before_main):
+                        await self.__before_main(self.__session.page)
+                    elif callable(self.__before_main):
+                        self.__before_main(self.__session.page)
+                except Exception as e:
+                    register_error = f"{e}\n{traceback.format_exc()}"
+                    logger.error(
+                        "Unhandled error in before_main() handler", exc_info=True
+                    )
 
             # register response
             self.send_message(
@@ -274,11 +279,15 @@ class FletApp(Connection):
                         page_patch=self.__session.get_page_patch()
                         if new_session
                         else self.__session.page,
-                        error="",
+                        error=register_error,
                     ),
                 )
             )
 
+            if register_error:
+                self.__session.error(register_error)
+                return
+
             # start session
             if new_session:
                 asyncio.create_task(self.__on_session_created())
@@ -325,7 +334,7 @@ class FletApp(Connection):
 
         else:
             # it's something else
-            raise Exception(f'Unknown message "{action}": {body}')
+            raise RuntimeError(f'Unknown message "{action}": {body}')
 
         if task:
             self.__running_tasks.add(task)

flet_web/fastapi/flet_app_manager.py

@@ -6,11 +6,10 @@ from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
 from typing import Optional
 
+import flet_web.fastapi as flet_fastapi
 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
 
 logger = logging.getLogger(flet_fastapi.__name__)
@@ -84,7 +83,7 @@ class FletAppManager:
             session = self.__sessions[session_id]
             await session.connect(conn)
         else:
-            raise Exception(f"Session has expired or not found: {session_id}")
+            raise RuntimeError(f"Session has expired or not found: {session_id}")
 
     async def disconnect_session(self, session_id: str, session_timeout_seconds: int):
         logger.info(f"Session disconnected: {session_id}")

flet_web/fastapi/flet_static_files.py

@@ -6,11 +6,11 @@ from pathlib import Path
 from typing import Optional
 
 from fastapi.staticfiles import StaticFiles
-from flet.controls.types import RouteUrlStrategy, WebRenderer
-from flet.utils import Once, get_bool_env_var
 from starlette.types import Receive, Scope, Send
 
 import flet_web.fastapi as flet_fastapi
+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_font_manifest_json,
@@ -120,7 +120,7 @@ class FletStaticFiles(StaticFiles):
         logger.info(f"Web root: {web_dir}")
 
         if not os.path.exists(web_dir):
-            raise Exception(f"Web root path not found: {web_dir}")
+            raise RuntimeError(f"Web root path not found: {web_dir}")
 
         # user-defined assets
         if self.__assets_dir:

flet_web/fastapi/flet_upload.py

@@ -3,9 +3,10 @@ import os
 from datetime import datetime, timezone
 from typing import Optional
 
-import flet_web.fastapi as flet_fastapi
 from anyio import open_file
-from fastapi import Request
+from fastapi import HTTPException, Request, status
+
+import flet_web.fastapi as flet_fastapi
 from flet_web.uploads import build_upload_query_string, get_upload_signature
 
 logger = logging.getLogger(flet_fastapi.__name__)
@@ -18,7 +19,8 @@ class FletUpload:
     Parameters:
 
     * `upload_dir` (str) - an absolute path to a directory with uploaded files.
-    * `max_upload_size` (str, int) - maximum size of a single upload, bytes. Unlimited if `None`.
+    * `max_upload_size` (str, int) - maximum size of a single upload, bytes.
+       Unlimited if `None`.
     * `secret_key` (str, optional) - secret key to sign and verify upload requests.
     """
 
@@ -50,14 +52,24 @@ class FletUpload:
     """
 
     async def handle(self, request: Request):
-        file_name = request.query_params["f"]
-        expire_str = request.query_params["e"]
-        signature = request.query_params["s"]
+        query_params = request.query_params
+        file_name = query_params.get("f")
+        expire_str = query_params.get("e")
+        signature = query_params.get("s")
 
         if not file_name or not expire_str or not signature:
-            raise Exception("Invalid request")
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Missing upload parameters",
+            )
 
-        expire_date = datetime.fromisoformat(expire_str)
+        try:
+            expire_date = datetime.fromisoformat(expire_str)
+        except ValueError as e:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Invalid expiration parameter",
+            ) from e
 
         # verify signature
         query_string = build_upload_query_string(file_name, expire_date)
@@ -67,17 +79,26 @@ class FletUpload:
             )
             != signature
         ):
-            raise Exception("Invalid request")
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Invalid upload signature",
+            )
 
         # check expiration date
         if datetime.now(timezone.utc) >= expire_date:
-            raise Exception("Invalid request")
+            raise HTTPException(
+                status_code=status.HTTP_410_GONE,
+                detail="Upload URL has expired",
+            )
 
         # build/validate dest path
         joined_path = os.path.join(self.__upload_dir, file_name)
         full_path = os.path.realpath(joined_path)
         if os.path.commonpath([full_path, self.__upload_dir]) != self.__upload_dir:
-            raise Exception("Invalid request")
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Invalid upload destination",
+            )
 
         # create directory if not exists
         dest_dir = os.path.dirname(full_path)
@@ -89,7 +110,9 @@ class FletUpload:
             async for chunk in request.stream():
                 size += len(chunk)
                 if self.__max_upload_size and size > self.__max_upload_size:
-                    raise Exception(
-                        f"Max upload size reached: {self.__max_upload_size}"
+                    raise HTTPException(
+                        status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+                        detail="Max upload size exceeded: "
+                        f"{self.__max_upload_size} bytes",
                     )
                 await f.write(chunk)

flet_web/uploads.py

@@ -39,8 +39,9 @@ def get_upload_signature(
     if env_secret_key:
         secret_key = env_secret_key
     if not secret_key:
-        raise Exception(
-            "Specify secret_key parameter or set FLET_SECRET_KEY environment variable to enable uploads."
+        raise RuntimeError(
+            "Specify secret_key parameter or set FLET_SECRET_KEY environment "
+            "variable to enable uploads."
         )
     signing_key = hmac.new(
         secret_key.encode("utf-8"),
@@ -49,6 +50,6 @@ def get_upload_signature(
     ).digest()
     return hmac.new(
         signing_key,
-        f"{upload_endpoint_path.strip('/')}{query_string}".encode("utf-8"),
+        f"{upload_endpoint_path.strip('/')}{query_string}".encode(),
         hashlib.sha256,
     ).hexdigest()

flet_web/version.py

@@ -1 +1 @@
-version = "0.70.0.dev6516"
+version = "0.70.0.dev6616"

flet_web/web/flutter_bootstrap.js

@@ -55,7 +55,7 @@ if (flet.noCdn) {
 _flutter.loader.load({
     config: flutterConfig,
     serviceWorkerSettings: {
-        serviceWorkerVersion: "159190134",
+        serviceWorkerVersion: "1655580612",
     },
     onEntrypointLoaded: async function (engineInitializer) {
         loading.classList.add('main_done');

flet_web/web/flutter_service_worker.js

@@ -43,10 +43,10 @@ const RESOURCES = {"flutter.js": "888483df48293866f9f41d3d9274a779",
 "canvaskit/skwasm.js.symbols": "0088242d10d7e7d6d2649d1fe1bda7c1",
 "python-worker.js": "26eb131f3acb5ce232fea72da957e8ce",
 "favicon.png": "302ac04c14db027d016d1fe74c6a80a0",
-"main.dart.wasm": "35e35486894562464bdcd966aa0c9447",
-"flutter_bootstrap.js": "5910c8294fd646b00b542ffadf74f08d",
+"main.dart.wasm": "235be5bad710db8c4e2d34e13c332438",
+"flutter_bootstrap.js": "666833912535cd573d1cebc76ab4bb32",
 "version.json": "3fea9d9c7b4ca6955aa03e762e0d2e13",
-"main.dart.js": "3c75fba92d0cdd27d1538d499b46adf5"};
+"main.dart.js": "8d6a52f9f0f4b292cc98bfbfc96bb853"};
 // The application shell files that are downloaded before a service worker can
 // start.
 const CORE = ["main.dart.js",