flet-web 0.25.0__py3-none-any.whl

flet_web/fastapi/flet_fastapi.py

@@ -0,0 +1,128 @@
+import asyncio
+from contextlib import asynccontextmanager
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Coroutine,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Type,
+    Union,
+)
+
+import fastapi
+import flet_web.fastapi
+from fastapi.datastructures import Default
+from fastapi.params import Depends
+from fastapi.utils import generate_unique_id
+from starlette.middleware import Middleware
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+from starlette.routing import BaseRoute
+
+
+class FastAPI(fastapi.FastAPI):
+    def __init__(
+        self,
+        *,
+        debug: bool = False,
+        routes: Optional[List[BaseRoute]] = None,
+        title: str = "FastAPI",
+        summary: Optional[str] = None,
+        description: str = "",
+        version: str = "0.1.0",
+        openapi_url: Optional[str] = "/openapi.json",
+        openapi_tags: Optional[List[Dict[str, Any]]] = None,
+        servers: Optional[List[Dict[str, Union[str, Any]]]] = None,
+        dependencies: Optional[Sequence[Depends]] = None,
+        default_response_class: Type[Response] = Default(JSONResponse),
+        redirect_slashes: bool = True,
+        docs_url: Optional[str] = "/docs",
+        redoc_url: Optional[str] = "/redoc",
+        swagger_ui_oauth2_redirect_url: Optional[str] = "/docs/oauth2-redirect",
+        swagger_ui_init_oauth: Optional[Dict[str, Any]] = None,
+        middleware: Optional[Sequence[Middleware]] = None,
+        exception_handlers: Optional[
+            Dict[
+                Union[int, Type[Exception]],
+                Callable[[Request, Any], Coroutine[Any, Any, Response]],
+            ]
+        ] = None,
+        on_startup: Optional[Sequence[Callable[[], Optional[Awaitable]]]] = None,
+        on_shutdown: Optional[Sequence[Callable[[], Optional[Awaitable]]]] = None,
+        terms_of_service: Optional[str] = None,
+        contact: Optional[Dict[str, Union[str, Any]]] = None,
+        license_info: Optional[Dict[str, Union[str, Any]]] = None,
+        openapi_prefix: str = "",
+        root_path: str = "",
+        root_path_in_servers: bool = True,
+        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+        callbacks: Optional[List[BaseRoute]] = None,
+        webhooks: Optional[fastapi.routing.APIRouter] = None,
+        deprecated: Optional[bool] = None,
+        include_in_schema: bool = True,
+        swagger_ui_parameters: Optional[Dict[str, Any]] = None,
+        generate_unique_id_function: Callable[
+            [fastapi.routing.APIRoute], str
+        ] = Default(generate_unique_id),
+        **extra: Any,
+    ) -> None:
+        @asynccontextmanager
+        async def lifespan(app: fastapi.FastAPI):
+            await flet_web.fastapi.app_manager.start()
+            if on_startup:
+                for h in on_startup:
+                    if asyncio.iscoroutinefunction(h):
+                        await h()
+                    else:
+                        h()
+
+            yield
+            if on_shutdown:
+                for h in on_shutdown:
+                    if asyncio.iscoroutinefunction(h):
+                        await h()
+                    else:
+                        h()
+            await flet_web.fastapi.app_manager.shutdown()
+
+        super().__init__(
+            debug=debug,
+            routes=routes,
+            title=title,
+            summary=summary,
+            description=description,
+            version=version,
+            openapi_url=openapi_url,
+            openapi_tags=openapi_tags,
+            servers=servers,
+            dependencies=dependencies,
+            default_response_class=default_response_class,
+            redirect_slashes=redirect_slashes,
+            docs_url=docs_url,
+            redoc_url=redoc_url,
+            swagger_ui_oauth2_redirect_url=swagger_ui_oauth2_redirect_url,
+            swagger_ui_init_oauth=swagger_ui_init_oauth,
+            middleware=middleware,
+            exception_handlers=exception_handlers,
+            # on_startup=on_startup,
+            # on_shutdown=on_shutdown,
+            lifespan=lifespan,
+            terms_of_service=terms_of_service,
+            contact=contact,
+            license_info=license_info,
+            openapi_prefix=openapi_prefix,
+            root_path=root_path,
+            root_path_in_servers=root_path_in_servers,
+            responses=responses,
+            callbacks=callbacks,
+            webhooks=webhooks,
+            deprecated=deprecated,
+            include_in_schema=include_in_schema,
+            swagger_ui_parameters=swagger_ui_parameters,
+            generate_unique_id_function=generate_unique_id_function,
+            **extra,
+        )

flet_web/fastapi/flet_oauth.py

@@ -0,0 +1,66 @@
+from fastapi import HTTPException, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+from flet_web.fastapi.flet_app_manager import app_manager
+
+
+class FletOAuth:
+    """
+    HTTP handler for OAuth callback.
+    """
+
+    def __init__(self) -> None:
+        pass
+
+    async def handle(self, request: Request):
+        """
+        Handle OAuth callback request.
+
+        Request must contain minimum `code` and `state` query parameters.
+
+        Returns either redirect to a Flet page or a HTML page with further instructions.
+        """
+        state_id = request.query_params.get("state")
+
+        if not state_id:
+            raise HTTPException(status_code=400, detail="Invalid state")
+
+        state = app_manager.retrieve_state(state_id)
+
+        if not state:
+            raise HTTPException(status_code=400, detail="Invalid state")
+
+        session = await app_manager.get_session(state.session_id)
+        if not session:
+            raise HTTPException(status_code=500, detail="Session not found")
+
+        await session._authorize_callback_async(
+            {
+                "state": state_id,
+                "code": request.query_params.get("code"),
+                "error": request.query_params.get("error"),
+                "error_description": request.query_params.get("error_description"),
+            }
+        )
+
+        if state.complete_page_url:
+            return RedirectResponse(state.complete_page_url)
+        else:
+            html_content = (
+                state.complete_page_html
+                if state.complete_page_html
+                else f"""
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <title>Signed in successfully</title>
+            </head>
+            <body>
+                <script type="text/javascript">
+                    window.close();
+                </script>
+                <p>You've been successfully signed in! You can close this tab or window now.</p>
+            </body>
+            </html>
+            """
+            )
+            return HTMLResponse(content=html_content, status_code=200)

flet_web/fastapi/flet_static_files.py

@@ -0,0 +1,188 @@
+import logging
+import os
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Optional, Tuple
+
+import flet_web.fastapi as flet_fastapi
+from fastapi.staticfiles import StaticFiles
+from flet.core.types import 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
+
+logger = logging.getLogger(flet_fastapi.__name__)
+
+
+class FletStaticFiles(StaticFiles):
+    """
+    Serve Flet app static files.
+
+    Parameters:
+
+    * `app_mount_path` (str) - absolute URL of Flet app. Default is `/`.
+    * `assets_dir` (str, optional) - an absolute path to app's assets directory.
+    * `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`.
+    * `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`.
+    """
+
+    def __init__(
+        self,
+        proxy_path: Optional[str] = None,
+        assets_dir: Optional[str] = None,
+        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",
+        websocket_endpoint_path: Optional[str] = None,
+    ) -> None:
+        self.index = "index.html"
+        self.manifest_json = "manifest.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.__websocket_endpoint_path = websocket_endpoint_path
+        self.__once = Once()
+
+        env_web_renderer = os.getenv("FLET_WEB_RENDERER")
+        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
+
+        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}")
+
+    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]]:
+        """Returns the index file when no match is found.
+
+        Args:
+            path (str): Resource path.
+
+        Returns:
+            [tuple[str, os.stat_result]]: Always retuens a full path and stat result.
+        """
+        logger.debug(f"StaticFiles.lookup_path: {self.__app_mount_path} {path}")
+        full_path, stat_result = super().lookup_path(path)
+
+        # if a file cannot be found
+        if stat_result is None:
+            return super().lookup_path(self.index)
+
+        return full_path, stat_result
+
+    async def __config(self, root_path: str):
+        if self.__proxy_path:
+            self.__app_mount_path = self.__proxy_path + root_path
+        else:
+            self.__app_mount_path = root_path
+
+        # where modified index.html is stored
+        temp_dir = tempfile.mkdtemp()
+        app_manager.add_temp_dir(temp_dir)
+        logger.info(f"Temp dir created for patched index and manifest: {temp_dir}")
+
+        # "standard" web files
+        web_dir = get_package_web_dir()
+        logger.info(f"Web root: {web_dir}")
+
+        if not os.path.exists(web_dir):
+            raise Exception(f"Web root path not found: {web_dir}")
+
+        # user-defined assets
+        if self.__assets_dir:
+            if not Path(self.__assets_dir).is_absolute():
+                logger.warning("assets_dir must be absolute path.")
+                self.__assets_dir = None
+            elif not os.path.exists(self.__assets_dir):
+                logger.info(f"assets_dir does not exist: {self.__assets_dir}")
+                self.__assets_dir = None
+
+        logger.info(f"Assets dir: {self.__assets_dir}")
+
+        # 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 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),
+            )
+
+        ws_path = self.__websocket_endpoint_path
+        if not ws_path:
+            ws_path = self.__app_mount_path.strip("/")
+            ws_path = f"{'' if ws_path == '' else '/'}{ws_path}/ws"
+
+        # replace variables in index.html and manifest.json
+        patch_index_html(
+            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,
+            route_url_strategy=self.__route_url_strategy,
+        )
+
+        patch_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,
+        )
+
+        # 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)
+
+        # add the rest of dirs
+        if self.__assets_dir:
+            self.all_directories.append(self.__assets_dir)
+
+        self.all_directories.append(web_dir)

flet_web/fastapi/flet_upload.py

@@ -0,0 +1,95 @@
+import logging
+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 flet_web.uploads import build_upload_query_string, get_upload_signature
+
+logger = logging.getLogger(flet_fastapi.__name__)
+
+
+class FletUpload:
+    """
+    Flet app uploads handler.
+
+    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`.
+    * `secret_key` (str, optional) - secret key to sign and verify upload requests.
+    """
+
+    def __init__(
+        self,
+        upload_dir: str,
+        max_upload_size: Optional[int] = None,
+        secret_key: Optional[str] = None,
+    ) -> None:
+        self.__upload_dir = os.path.realpath(upload_dir)
+        self.__max_upload_size = max_upload_size
+
+        env_max_upload_size = os.getenv("FLET_MAX_UPLOAD_SIZE")
+        if env_max_upload_size:
+            self.__max_upload_size = int(env_max_upload_size)
+
+        self.__secret_key = secret_key
+
+        env_upload_secret_key = os.getenv("FLET_SECRET_KEY")
+        if env_upload_secret_key:
+            self.__secret_key = env_upload_secret_key
+
+        logger.info(f"Upload path configured: {self.__upload_dir}")
+
+    """
+    Handle file upload.
+
+    Upload must be an non-encoded (raw) file in the requst body.
+    """
+
+    async def handle(self, request: Request):
+        file_name = request.query_params["f"]
+        expire_str = request.query_params["e"]
+        signature = request.query_params["s"]
+
+        if not file_name or not expire_str or not signature:
+            raise Exception("Invalid request")
+
+        expire_date = datetime.fromisoformat(expire_str)
+
+        # verify signature
+        query_string = build_upload_query_string(file_name, expire_date)
+        if (
+            get_upload_signature(
+                request.url.path, query_string, expire_date, self.__secret_key
+            )
+            != signature
+        ):
+            raise Exception("Invalid request")
+
+        # check expiration date
+        if datetime.now(timezone.utc) >= expire_date:
+            raise Exception("Invalid request")
+
+        # 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")
+
+        # create directory if not exists
+        dest_dir = os.path.dirname(full_path)
+        os.makedirs(dest_dir, exist_ok=True)
+
+        # upload file
+        size = 0
+        async with await open_file(full_path, "wb") as f:
+            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}"
+                    )
+                await f.write(chunk)

flet_web/fastapi/oauth_state.py

@@ -0,0 +1,11 @@
+import dataclasses
+from datetime import datetime
+from typing import Optional
+
+
+@dataclasses.dataclass
+class OAuthState:
+    session_id: str
+    expires_at: datetime
+    complete_page_url: Optional[str] = dataclasses.field(default=None)
+    complete_page_html: Optional[str] = dataclasses.field(default=None)

flet_web/fastapi/serve_fastapi_web_app.py

@@ -0,0 +1,94 @@
+import asyncio
+import logging
+from typing import Optional
+
+import uvicorn
+from flet.core.types import WebRenderer
+
+import flet_web.fastapi
+import flet_web.fastapi as flet_fastapi
+
+logger = logging.getLogger(flet_fastapi.__name__)
+
+
+class WebServerHandle:
+    def __init__(self, page_url: str, server: uvicorn.Server) -> None:
+        self.page_url = page_url
+        self.server = server
+
+    async def close(self):
+        logger.info("Closing Flet web server...")
+        await self.server.shutdown()
+
+
+def get_fastapi_web_app(
+    session_handler,
+    page_name: str,
+    assets_dir,
+    upload_dir,
+    web_renderer: Optional[WebRenderer],
+    use_color_emoji,
+    route_url_strategy,
+):
+    web_path = f"/{page_name.strip('/')}"
+    app = flet_web.fastapi.FastAPI()
+    app.mount(
+        web_path,
+        flet_web.fastapi.app(
+            session_handler,
+            upload_dir=upload_dir,
+            assets_dir=assets_dir,
+            web_renderer=web_renderer if web_renderer else WebRenderer.AUTO,
+            use_color_emoji=use_color_emoji,
+            route_url_strategy=route_url_strategy,
+        ),
+    )
+
+    return app
+
+
+async def serve_fastapi_web_app(
+    session_handler,
+    host,
+    url_host,
+    port,
+    page_name: str,
+    assets_dir,
+    upload_dir,
+    web_renderer: Optional[WebRenderer],
+    use_color_emoji,
+    route_url_strategy,
+    blocking,
+    on_startup,
+    log_level,
+):
+
+    web_path = f"/{page_name.strip('/')}"
+    page_url = f"http://{url_host}:{port}{web_path if web_path != '/' else ''}"
+
+    def startup():
+        if on_startup:
+            on_startup(page_url)
+
+    app = flet_web.fastapi.FastAPI(on_startup=[startup])
+
+    app.mount(
+        web_path,
+        flet_web.fastapi.app(
+            session_handler,
+            upload_dir=upload_dir,
+            assets_dir=assets_dir,
+            web_renderer=web_renderer if web_renderer else WebRenderer.AUTO,
+            use_color_emoji=use_color_emoji,
+            route_url_strategy=route_url_strategy,
+        ),
+    )
+    config = uvicorn.Config(app, host=host, port=port, log_level=log_level)
+    server = uvicorn.Server(config)
+
+    if blocking:
+        await server.serve()
+    else:
+        asyncio.create_task(server.serve())
+
+    return WebServerHandle(page_url=page_url, server=server)

flet_web/patch_index.py

@@ -0,0 +1,112 @@
+import json
+import re
+from pathlib import Path
+from typing import Optional
+
+from flet.core.types import WebRenderer
+
+
+def patch_index_html(
+    index_path: str,
+    base_href: str,
+    websocket_endpoint_path: Optional[str] = None,
+    app_name: Optional[str] = None,
+    app_description: Optional[str] = None,
+    pyodide: bool = False,
+    pyodide_pre: bool = False,
+    pyodide_script_path: str = "",
+    web_renderer: WebRenderer = WebRenderer.AUTO,
+    use_color_emoji: bool = False,
+    route_url_strategy: str = "path",
+):
+    with open(index_path, "r") as f:
+        index = f.read()
+
+    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>',
+    )
+    index = index.replace(
+        "<!-- useColorEmoji -->",
+        f"<script>useColorEmoji={str(use_color_emoji).lower()};</script>",
+    )
+    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,
+        )
+    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),
+            index,
+        )
+        index = re.sub(
+            r"\<title>(.+)</title>",
+            r"<title>{}</title>".format(app_name),
+            index,
+        )
+    if app_description:
+        index = re.sub(
+            r"\<meta name=\"description\" content=\"(.+)\">",
+            r'<meta name="description" content="{}">'.format(app_description),
+            index,
+        )
+
+    with open(index_path, "w") as f:
+        f.write(index)
+
+
+def patch_manifest_json(
+    manifest_path: str,
+    app_name: Optional[str] = None,
+    app_short_name: Optional[str] = None,
+    app_description: Optional[str] = None,
+    background_color: Optional[str] = None,
+    theme_color: Optional[str] = None,
+):
+    with open(manifest_path, "r") as f:
+        manifest = json.loads(f.read())
+
+    if app_name:
+        manifest["name"] = app_name
+        manifest["short_name"] = app_name
+
+    if app_short_name:
+        manifest["short_name"] = app_short_name
+
+    if app_description:
+        manifest["description"] = app_description
+
+    if background_color:
+        manifest["background_color"] = background_color
+
+    if theme_color:
+        manifest["theme_color"] = theme_color
+
+    with open(manifest_path, "w") as f:
+        f.write(json.dumps(manifest, indent=2))