flet-web 0.1.0__py3-none-any.whl

flet_web/__init__.py

@@ -0,0 +1,9 @@
+import os
+from pathlib import Path
+
+from flet_web.patch_index import patch_index_html, patch_manifest_json
+
+
+def get_package_web_dir():
+    web_root_dir = os.environ.get("FLET_WEB_PATH")
+    return web_root_dir or str(Path(__file__).parent.joinpath("web"))

flet_web/fastapi/README.md

@@ -0,0 +1,146 @@
+# Flet - a better UI for FastAPI
+
+Flet for FastAPI allows adding interactive real-time dashboards to your FastAPI app as well as host any Flet web app inside FastAPI with production-grade reliability.
+
+## Installation
+
+```
+pip install flet-fastapi
+```
+
+## First app
+
+Create `counter.py` with the following content:
+
+```python
+import flet as ft
+import flet_fastapi
+
+async def main(page: ft.Page):
+    counter = ft.Text("0", size=50, data=0)
+
+    async def add_click(e):
+        counter.data += 1
+        counter.value = str(counter.data)
+        counter.update()
+
+    page.floating_action_button = ft.FloatingActionButton(
+        icon=ft.icons.ADD, on_click=add_click
+    )
+    await page.add_async(
+        ft.Container(counter, alignment=ft.alignment.center, expand=True)
+    )
+
+app = flet_fastapi.app(main)
+```
+
+That's a simple app displaying a counter and a button at the right bottom to increment that counter.
+
+`flet_fastapi.app()` configures a single Flet app at the root of FastAPI app with `main()` sessions handler and the following endpoints:
+
+`/ws` (WS) - WebSocket handler for the Flet app.
+
+`/upload` (PUT) - file uploads handler.
+
+`/oauth_callback` (GET) - OAuth flow callback handler.
+
+`/` (GET) - Flet app static files with SPA catch-all handler.
+
+## Running the app locally
+
+Install [Uvicorn](https://www.uvicorn.org/) web server:
+
+```
+pip install uvicorn
+```
+
+Start `uvicorn` with:
+
+```
+uvicorn counter:app
+```
+
+Open the browser and navigate to http://127.0.0.1:8000 to see the app running.
+
+## Hosting multiple Flet apps under the same domain
+
+```python
+import flet as ft
+import flet_fastapi
+
+
+async def root_main(page: ft.Page):
+    await page.add_async(ft.Text("This is root app!"))
+
+
+async def sub_main(page: ft.Page):
+    await page.add_async(ft.Text("This is sub app!"))
+
+
+app = flet_fastapi.FastAPI()
+
+
+app.mount("/sub-app", flet_fastapi.app(sub_main))
+app.mount("/", flet_fastapi.app(root_main))
+```
+
+Sub-apps must be mapped before the root Flet app as it configures catch-all `index.html` for SPA.
+
+Run the app with `uvicorn` and visit http://127.0.0.1:8000 and then http://127.0.0.1:8000/sub-app/ to see both Flet apps running. Notice the trailing slash in `/sub-app/` URL - without the slash the request will be routed to a root app.
+
+## Adding Flet to the existing FastAPI app
+
+```python
+from contextlib import asynccontextmanager
+
+import flet as ft
+import flet_fastapi
+from fastapi import FastAPI
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await flet_fastapi.app_manager.start()
+    yield
+    await flet_fastapi.app_manager.shutdown()
+
+app = FastAPI(lifespan=lifespan)
+
+async def main(page: ft.Page):
+    await page.add_async(ft.Text("Hello, Flet!"))
+
+app.mount("/flet-app", flet_fastapi.app(main))
+```
+
+When adding Flet app to the existing FastAPI app you need to call `flet_fastapi.app_manager.start()` on app start and `flet_fastapi.app_manager.shutdown()` on shutdown. Use the way that best suites you: lifespan (in the example above) or app events.
+
+`app_manager.start()` method starts background tasks cleaning up expired sessions and OAuth flow states.
+
+`app_manager.shutdown()` method removes any temporary files created by a Flet app.
+
+## Running the app in production
+
+It is recommended to run FastAPI in production with [Hypercorn](https://github.com/pgjones/hypercorn/) which is ASGI web server, but it is also possible to run FastAPI apps with [Gunicorn](https://gunicorn.org/) which is a WSGI server, but has more features, like passing proxy headers.
+
+To install Gunicorn:
+
+```
+pip install gunicorn
+```
+
+Start `gunicorn` with:
+
+```
+gunicorn -k uvicorn.workers.UvicornWorker counter:app
+```
+
+## Reference
+
+### Environment variables
+
+`FLET_SECRET_KEY` - secret key to sign upload requests. Must be set if upload directory is configured.
+
+`FLET_SESSION_TIMEOUT` - the number of seconds to keep session alive after user has disconnected. Default is 3,600 seconds.
+
+`FLET_OAUTH_STATE_TIMEOUT` - OAuth state lifetime, in seconds, which is a maximum allowed time between starting OAuth flow and redirecting to OAuth callback URL. Default is 600 seconds.
+
+`FLET_MAX_UPLOAD_SIZE` - max allowed size of an uploaded file, bytes.

flet_web/fastapi/__init__.py

@@ -0,0 +1,6 @@
+from flet_web.fastapi.app import app
+from flet_web.fastapi.flet_app import FletApp
+from flet_web.fastapi.flet_app_manager import app_manager
+from flet_web.fastapi.flet_fastapi import FastAPI
+from flet_web.fastapi.flet_static_files import FletStaticFiles
+from flet_web.fastapi.flet_upload import FletUpload

flet_web/fastapi/app.py

@@ -0,0 +1,121 @@
+import asyncio
+import os
+from typing import Awaitable, Callable, Optional, Union
+
+from fastapi import Request, WebSocket
+from flet.core.page import Page
+from flet.core.types import WebRenderer
+
+from flet_web.fastapi.flet_app import (
+    DEFAULT_FLET_OAUTH_STATE_TIMEOUT,
+    DEFAULT_FLET_SESSION_TIMEOUT,
+    FletApp,
+)
+from flet_web.fastapi.flet_fastapi import FastAPI
+from flet_web.fastapi.flet_oauth import FletOAuth
+from flet_web.fastapi.flet_static_files import FletStaticFiles
+from flet_web.fastapi.flet_upload import FletUpload
+
+
+def app(
+    session_handler: Union[Callable[[Page], Awaitable], Callable[[Page], None]],
+    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",
+    upload_dir: Optional[str] = None,
+    upload_endpoint_path: Optional[str] = None,
+    max_upload_size: Optional[int] = None,
+    secret_key: Optional[str] = None,
+    session_timeout_seconds: int = DEFAULT_FLET_SESSION_TIMEOUT,
+    oauth_state_timeout_seconds: int = DEFAULT_FLET_OAUTH_STATE_TIMEOUT,
+):
+    """
+    Mount all Flet FastAPI handlers in one call.
+
+    Parameters:
+    * `session_handler` (function or coroutine) - application entry point - a method called for newly connected user. Handler must have 1 parameter: `page` - `Page` instance.
+    * `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`.
+    * `upload_dir` (str) - an absolute path to a directory with uploaded files.
+    * `upload_endpoint_path` (str, optional) - absolute URL of upload endpoint, e.g. `/upload`.
+    * `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.
+    * `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.
+    """
+
+    env_upload_dir = os.getenv("FLET_UPLOAD_DIR")
+    if env_upload_dir:
+        upload_dir = env_upload_dir
+
+    env_websocket_endpoint = os.getenv("FLET_WEBSOCKET_HANDLER_ENDPOINT")
+    websocket_endpoint = (
+        "ws" if not env_websocket_endpoint else env_websocket_endpoint.strip("/")
+    )
+
+    env_upload_endpoint = os.getenv("FLET_UPLOAD_HANDLER_ENDPOINT")
+    upload_endpoint = (
+        "upload" if not env_upload_endpoint else env_upload_endpoint.strip("/")
+    )
+
+    env_oauth_callback_endpoint = os.getenv("FLET_OAUTH_CALLBACK_HANDLER_ENDPOINT")
+    oauth_callback_endpoint = (
+        "oauth_callback"
+        if not env_oauth_callback_endpoint
+        else env_oauth_callback_endpoint.strip("/")
+    )
+
+    fastapi_app = FastAPI()
+
+    @fastapi_app.websocket(f"/{websocket_endpoint}")
+    async def app_handler(websocket: WebSocket):
+        await FletApp(
+            asyncio.get_running_loop(),
+            session_handler,
+            session_timeout_seconds=session_timeout_seconds,
+            oauth_state_timeout_seconds=oauth_state_timeout_seconds,
+            upload_endpoint_path=upload_endpoint_path,
+            secret_key=secret_key,
+        ).handle(websocket)
+
+    if upload_dir:
+
+        @fastapi_app.put(
+            f"/{upload_endpoint_path if upload_endpoint_path else upload_endpoint}"
+        )
+        async def upload_handler(request: Request):
+            await FletUpload(
+                upload_dir=upload_dir,
+                max_upload_size=max_upload_size,
+                secret_key=secret_key,
+            ).handle(request)
+
+    @fastapi_app.get(f"/{oauth_callback_endpoint}")
+    async def oauth_redirect_handler(request: Request):
+        return await FletOAuth().handle(request)
+
+    fastapi_app.mount(
+        path="/",
+        app=FletStaticFiles(
+            proxy_path=proxy_path,
+            assets_dir=assets_dir,
+            app_name=app_name,
+            app_short_name=app_short_name,
+            app_description=app_description,
+            web_renderer=web_renderer,
+            use_color_emoji=use_color_emoji,
+            route_url_strategy=route_url_strategy,
+        ),
+    )
+
+    return fastapi_app