fastapi-reloader 1.0__py2.py3-none-any.whl

fastapi_reloader/__init__.py

@@ -0,0 +1,4 @@
+from .core import send_reload_signal
+from .patcher import patch_for_auto_reloading
+
+__all__ = ["patch_for_auto_reloading", "send_reload_signal"]

fastapi_reloader/core.py

@@ -0,0 +1,63 @@
+from asyncio import Queue, ensure_future, sleep
+from collections import defaultdict
+from itertools import count
+from pathlib import Path
+from typing import Literal
+
+from fastapi import APIRouter, Response
+from fastapi.responses import StreamingResponse
+
+get_id = count().__next__
+
+requests: dict[int, list[Queue[Literal[0, 1]]]] = defaultdict(list)
+
+
+def send_reload_signal():
+    for subscribers in requests.values():
+        for queue in subscribers:
+            queue.put_nowait(1)
+
+
+hmr_router = APIRouter(prefix="/---fastapi-reloader---", tags=["hmr"])
+
+
+runtime_js = Path(__file__, "../runtime.js").read_text()
+
+
+def get_js():
+    return runtime_js.replace("/0", f"/{get_id()}")
+
+
+@hmr_router.head("")
+async def heartbeat():
+    return Response(status_code=200)
+
+
+@hmr_router.get("/{key:int}")
+async def simple_refresh_trigger(key: int):
+    async def event_generator():
+        queue = Queue[Literal[0, 1]]()
+
+        stopped = False
+
+        async def heartbeat():
+            while not stopped:
+                queue.put_nowait(0)
+                await sleep(1)
+
+        requests[key].append(queue)
+
+        heartbeat_future = ensure_future(heartbeat())
+
+        try:
+            yield "0\n"
+            while True:
+                value = await queue.get()
+                yield f"{value}\n"
+                if value == 1:
+                    break
+        finally:
+            heartbeat_future.cancel()
+            requests[key].remove(queue)
+
+    return StreamingResponse(event_generator(), media_type="text/plain")

fastapi_reloader/patcher.py

@@ -0,0 +1,43 @@
+from collections.abc import Awaitable, Callable
+from typing import TypeGuard
+
+from fastapi import FastAPI, Request, Response
+from fastapi.responses import StreamingResponse
+from starlette.middleware import Middleware
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.types import ASGIApp
+
+from .core import get_js, hmr_router
+
+
+def is_streaming_response(response: Response) -> TypeGuard[StreamingResponse]:
+    # In fact, it may not be a fastapi's StreamingResponse, but a starlette's one with the same interface
+    return hasattr(response, "body_iterator")
+
+
+def patch_for_auto_reloading(app: ASGIApp):
+    new_app = FastAPI(openapi_url=None)
+    new_app.include_router(hmr_router)
+    new_app.mount("/", app)
+
+    async def hmr_middleware(request: Request, call_next: Callable[[Request], Awaitable[Response]]):
+        res = await call_next(request)
+
+        if request.method != "GET" or "html" not in (res.headers.get("content-type", "")):
+            return res
+
+        async def response():
+            if is_streaming_response(res):
+                async for chunk in res.body_iterator:
+                    yield chunk
+            else:
+                yield res.body
+            yield f"\n\n <script> {get_js()} </script>".encode()
+
+        headers = {k: v for k, v in res.headers.items() if k.lower() not in {"content-length", "content-encoding", "transfer-encoding"}}
+
+        return StreamingResponse(response(), res.status_code, headers, res.media_type)
+
+    new_app.user_middleware.append(Middleware(BaseHTTPMiddleware, dispatch=hmr_middleware))  # the last middleware is the first one to be called
+
+    return new_app

fastapi_reloader/runtime.js

@@ -0,0 +1,27 @@
+(async function () {
+  const response = await fetch("/---fastapi-reloader---/0");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    if (value) {
+      const chunk = decoder.decode(value, { stream: true });
+      if (chunk.includes("1")) {
+        while (true) {
+          try {
+            const res = await fetch("/---fastapi-reloader---", {
+              method: "HEAD",
+            });
+            if (res.ok) {
+              break;
+            }
+          } catch (error) {}
+        }
+        location.reload();
+      }
+    }
+  }
+})();

fastapi_reloader-1.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.1
+Name: fastapi-reloader
+Version: 1.0
+Project-URL: Homepage, https://github.com/promplate/hmr
+Requires-Dist: fastapi~=0.115
+Requires-Dist: hmr~=0.4.0
+Description-Content-Type: text/markdown
+
+# FastAPI Reloader
+
+[![PyPI - Version](https://img.shields.io/pypi/v/fastapi-reloader)](https://pypi.org/project/fastapi-reloader/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dw/fastapi-reloader)](https://pepy.tech/projects/fastapi-reloader/)
+
+A lightweight middleware ASGI applications that enables automatic browser page reloading during development.
+
+## Features
+
+- 🔄 Automatic browser refresh when code changes (work with `uvicorn-hmr`)
+- 🚀 Works with any ASGI application
+- 🔌 Simple integration with just two function calls
+
+## Installation
+
+```sh
+pip install fastapi-reloader
+```
+
+For a more comprehensive development experience, consider using `uvicorn-hmr` which includes this package:
+
+```sh
+pip install uvicorn-hmr[all]
+```
+
+Then run your app with:
+
+```sh
+uvicorn-hmr main:app --reload
+```
+
+## Advanced Usage
+
+### Manual Integration
+
+```python
+from fastapi import FastAPI
+from fastapi_reloader import patch_for_auto_reloading
+
+app = FastAPI()  # or some other ASGI app
+
+app = patch_for_auto_reloading(app)  # this will return a new FastAPI app
+```
+
+### Manual Trigger
+
+You can manually trigger a reload from your code:
+
+```python
+from fastapi_reloader import send_reload_signal
+
+send_reload_signal()  # When you need to trigger a reload
+```
+
+## How It Works
+
+The package injects a small JavaScript snippet into your HTML responses that:
+
+1. Opens a long-lived connection to the server
+2. Listens for reload signals
+3. Start polling for heartbeat when `send_reload_signal` is called
+4. Reloads the page when heartbeat from new server is received
+
+## Configuration
+
+The package works out-of-the-box with default settings. No additional configuration is required.
+
+## Limitations
+
+- Unlike `uvicorn-hmr`, which does on-demand fine-grained reloading on the server side, this package simply reloads all the pages in the browser.
+- Designed for development use only (not for production)
+- Requires JavaScript to be enabled in the browser
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.

fastapi_reloader-1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+fastapi_reloader-1.0.dist-info/METADATA,sha256=Jwsu7h94NyFlc-8qTGKmuHzJE2t-zG-9-SK5K6DuNKM,2260
+fastapi_reloader-1.0.dist-info/WHEEL,sha256=EIrqRoDPs10x40oLVL4n4Pk5qQrfAB4xusd3Yd1GnUQ,94
+fastapi_reloader-1.0.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+fastapi_reloader/__init__.py,sha256=VE5m-0M92Weme8COqLs0LwIx5g6FHhqyOLGAgY6Zkzs,145
+fastapi_reloader/core.py,sha256=1U4CFQhu0I8Y8HqRfZBzI71WthGUF4D7MHIxp8_hg6U,1528
+fastapi_reloader/patcher.py,sha256=d2wG3eD6Hs0URBhJag0uMeYq-QQP_YJZXOkOCGllp7s,1656
+fastapi_reloader/runtime.js,sha256=ltpmyOLzDaUjjb2WcEldWpgyh69gvi4nCaRnTDjT1jc,676
+fastapi_reloader-1.0.dist-info/RECORD,,

fastapi_reloader-1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.4.4)
+Root-Is-Purelib: true
+Tag: py2.py3-none-any

fastapi_reloader-1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+
+[gui_scripts]
+