fastreact 0.1.0__py3-none-any.whl

fastreact/core.py

@@ -0,0 +1,256 @@
+import traceback
+import sys
+from pathlib import Path
+
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, FileResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+import httpx
+
+from .utils import build_traceback_html, NOT_FOUND_PAGE, NOT_ALLOWED_PAGE, is_browser_request
+
+
+class FastReact:
+    """
+    FastReact — FastAPI + React unified stack.
+
+    Route rules:
+      - Routes WITH react_prefix (default /api/) → React page routes
+          • Browser request  → serves index.html → React Router renders
+          • Non-browser      → 405 Not Allowed
+          • Unregistered     → 404
+      - Routes WITHOUT react_prefix → normal FastAPI routes
+          • Work exactly like regular FastAPI (JSON, Jinja, anything)
+          • Accessible by everyone (Postman, curl, browser)
+
+    Usage:
+        app = FastReact()
+
+        # React page route — browser only
+        @app.get("/api/users")
+        def users_page(): pass
+
+        # Normal API route — everyone
+        @app.get("/data/users")
+        def get_users():
+            return {"users": [...]}
+
+    Custom prefix:
+        app = FastReact(react_prefix="/ui/")
+    """
+
+    def __init__(
+        self,
+        react_dir: str = "frontend",
+        build_dir: str = "frontend_build",
+        dev: bool = False,
+        dev_port: int = 5173,
+        traceback_overlay: bool = True,
+        title: str = "FastReact App",
+        react_prefix: str = "/api/",
+    ):
+        self.react_dir = Path(react_dir)
+        self.build_dir = Path(build_dir)
+        self.dev = dev
+        self.dev_port = dev_port
+        self.traceback_overlay = traceback_overlay
+        # auto normalize: "ui/" → "/ui/" , "/ui" → "/ui/" , "ui" → "/ui/"
+        react_prefix = react_prefix.strip("/")
+        self.react_prefix = "/" + react_prefix + "/"
+        self._routes_finalized = False
+        self._react_page_routes: set[str] = set()  # registered React page paths
+
+        self._app = FastAPI(title=title)
+        self._setup_static()
+
+        if traceback_overlay:
+            self._setup_traceback_middleware()
+
+    def _setup_static(self):
+        """Mount /assets early."""
+        build_dir = self.build_dir
+        if not self.dev and build_dir.exists():
+            assets_dir = build_dir / "assets"
+            if assets_dir.exists():
+                self._app.mount(
+                    "/assets",
+                    StaticFiles(directory=str(assets_dir)),
+                    name="assets"
+                )
+
+    def _is_react_route(self, path: str) -> bool:
+        """Check if path starts with react_prefix."""
+        return path.startswith(self.react_prefix) or path == self.react_prefix.rstrip("/")
+
+    def _finalize_routes(self):
+        """
+        Register catch-all LAST so user API routes are matched first.
+        Called on first request via __call__.
+        """
+        if self._routes_finalized:
+            return
+        self._routes_finalized = True
+
+        app = self._app
+        build_dir = self.build_dir
+        dev = self.dev
+        dev_port = self.dev_port
+        react_page_routes = self._react_page_routes
+        react_prefix = self.react_prefix
+
+        # ── Serve root / ─────────────────────────────────────────────
+        if not dev and build_dir.exists():
+
+            @app.get("/", response_class=HTMLResponse)
+            async def serve_root():
+                return FileResponse(str(build_dir / "index.html"))
+
+            # ── Catch-all ─────────────────────────────────────────────
+            @app.get("/{full_path:path}", response_class=HTMLResponse)
+            async def catch_all(request: Request, full_path: str):
+                path = "/" + full_path
+
+                # ── React prefix route (/api/...) ─────────────────────
+                if path.startswith(react_prefix) or path == react_prefix.rstrip("/"):
+
+                    # Not registered → 404
+                    if path not in react_page_routes:
+                        return HTMLResponse(
+                            NOT_FOUND_PAGE.format(path=path),
+                            status_code=404
+                        )
+
+                    # Registered — check if browser
+                    accept = request.headers.get("accept", "")
+                    if not is_browser_request(accept):
+                        # Non-browser (Postman/curl) → 405
+                        return HTMLResponse(
+                            NOT_ALLOWED_PAGE.format(path=path),
+                            status_code=405
+                        )
+
+                    # Browser + registered → serve React
+                    return FileResponse(str(build_dir / "index.html"))
+
+                # ── Normal route (no prefix) ──────────────────────────
+                # Serve index.html for React Router sub-paths
+                index = build_dir / "index.html"
+                if index.exists():
+                    return FileResponse(str(index))
+
+                return HTMLResponse(
+                    NOT_FOUND_PAGE.format(path=path),
+                    status_code=404
+                )
+
+        elif dev:
+
+            @app.get("/", response_class=HTMLResponse)
+            async def proxy_root():
+                return await _proxy_to_vite("/", dev_port)
+
+            @app.get("/{full_path:path}")
+            async def proxy_dev(request: Request, full_path: str):
+                path = "/" + full_path
+
+                if path.startswith(react_prefix):
+                    if path not in react_page_routes:
+                        return HTMLResponse(NOT_FOUND_PAGE.format(path=path), status_code=404)
+                    accept = request.headers.get("accept", "")
+                    if not is_browser_request(accept):
+                        return HTMLResponse(NOT_ALLOWED_PAGE.format(path=path), status_code=405)
+
+                return await _proxy_to_vite(path, dev_port)
+
+        else:
+            @app.get("/", response_class=HTMLResponse)
+            async def no_react():
+                return HTMLResponse("""
+                    <html><body style='font-family:monospace;padding:2rem;background:#111;color:#eee'>
+                    <h2>⚡ FastReact Running</h2>
+                    <p>No React build found.</p>
+                    <p>Run: <code>cd frontend && npm run build</code></p>
+                    </body></html>
+                """)
+
+    def _setup_traceback_middleware(self):
+        app = self._app
+
+        @app.middleware("http")
+        async def traceback_middleware(request: Request, call_next):
+            try:
+                response = await call_next(request)
+                return response
+            except Exception as exc:
+                html = build_traceback_html(
+                    error_type=type(exc).__name__,
+                    error_message=str(exc),
+                    traceback_text=traceback.format_exc(),
+                    path=request.url.path,
+                    framework="FastAPI",
+                )
+                return HTMLResponse(content=html, status_code=500)
+
+    # ── Decorator delegation ──────────────────────────────────────────────
+
+    def _register(self, method: str, path: str, **kwargs):
+        """
+        Core registration logic.
+        Auto-normalizes path — adds leading slash if missing.
+        If path starts with react_prefix → track as React page route.
+        The actual response is handled by the catch-all.
+        """
+        # Auto-normalize: "data/status" → "/data/status"
+        if not path.startswith("/"):
+            path = "/" + path
+
+        if self._is_react_route(path):
+            # Track this path as an allowed React page route
+            self._react_page_routes.add(path)
+            # Return a pass-through decorator — catch-all handles the response
+            def decorator(f):
+                return f
+            return decorator
+        else:
+            # Normal FastAPI route — delegate directly
+            return getattr(self._app, method)(path, **kwargs)
+
+    def get(self, path: str, **kwargs):
+        return self._register("get", path, **kwargs)
+
+    def post(self, path: str, **kwargs):
+        return self._register("post", path, **kwargs)
+
+    def put(self, path: str, **kwargs):
+        return self._register("put", path, **kwargs)
+
+    def delete(self, path: str, **kwargs):
+        return self._register("delete", path, **kwargs)
+
+    def patch(self, path: str, **kwargs):
+        return self._register("patch", path, **kwargs)
+
+    def include_router(self, router, **kwargs):
+        return self._app.include_router(router, **kwargs)
+
+    # ── ASGI entrypoint ───────────────────────────────────────────────────
+
+    async def __call__(self, scope, receive, send):
+        self._finalize_routes()
+        await self._app(scope, receive, send)
+
+
+async def _proxy_to_vite(path: str, port: int) -> HTMLResponse:
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(f"http://localhost:{port}{path}")
+            return HTMLResponse(content=response.text, status_code=response.status_code)
+    except Exception:
+        return HTMLResponse(
+            f"""<html><body style='font-family:monospace;padding:2rem;background:#111;color:#eee'>
+            <h2>⚡ FastReact Dev Mode</h2>
+            <p>Vite dev server not running on port {port}.</p>
+            <p>Run: <code>cd frontend && npm run dev</code></p>
+            </body></html>""",
+            status_code=503
+        )

fastreact/flask_core.py

@@ -0,0 +1,188 @@
+import traceback
+from pathlib import Path
+
+from .utils import build_traceback_html, NOT_FOUND_PAGE, NOT_ALLOWED_PAGE, is_browser_request
+
+try:
+    from flask import Flask, send_from_directory, request as flask_request
+except ImportError:
+    raise ImportError("Flask is not installed. Run: pip install flask")
+
+
+class FlaskReact:
+    """
+    FlaskReact — Flask + React unified stack.
+
+    Route rules:
+      - Routes WITH react_prefix (default /api/) → React page routes
+          • Browser request  → serves index.html → React Router renders
+          • Non-browser      → 405 Not Allowed
+          • Unregistered     → 404
+      - Routes WITHOUT react_prefix → normal Flask routes
+          • Work exactly like regular Flask
+          • Accessible by everyone
+
+    Usage:
+        app = FlaskReact()
+
+        # React page route — browser only
+        @app.route("/api/users")
+        def users_page(): pass
+
+        # Normal route — everyone
+        @app.route("/data/users")
+        def get_users():
+            return {"users": [...]}
+
+        app.run()
+
+    Custom prefix:
+        app = FlaskReact(react_prefix="/ui/")
+    """
+
+    def __init__(
+        self,
+        react_dir: str = "frontend",
+        build_dir: str = "frontend_build",
+        traceback_overlay: bool = True,
+        title: str = "FlaskReact App",
+        react_prefix: str = "/api/",
+    ):
+        self.react_dir = Path(react_dir)
+        self.build_dir = Path(build_dir)
+        self.traceback_overlay = traceback_overlay
+        # auto normalize: "ui/" → "/ui/" , "/ui" → "/ui/" , "ui" → "/ui/"
+        react_prefix = react_prefix.strip("/")
+        self.react_prefix = "/" + react_prefix + "/"
+        self._react_page_routes: set[str] = set()
+
+        self._app = Flask(title)
+
+        self._setup_react_serving()
+
+        if traceback_overlay:
+            self._setup_traceback_overlay()
+
+    def _is_react_route(self, path: str) -> bool:
+        return path.startswith(self.react_prefix) or path == self.react_prefix.rstrip("/")
+
+    def _setup_react_serving(self):
+        """Serve React build + handle routing rules."""
+        app = self._app
+        build_dir = self.build_dir
+        react_prefix = self.react_prefix
+        react_page_routes = self._react_page_routes
+
+        if build_dir.exists():
+
+            @app.route("/")
+            def serve_root():
+                return send_from_directory(str(build_dir), "index.html")
+
+            @app.route("/assets/<path:filename>")
+            def serve_assets(filename):
+                return send_from_directory(str(build_dir / "assets"), filename)
+
+            @app.route("/<path:full_path>")
+            def catch_all(full_path):
+                path = "/" + full_path
+
+                # ── React prefix route (/api/...) ─────────────────────
+                if path.startswith(react_prefix) or path == react_prefix.rstrip("/"):
+
+                    # Not registered → 404
+                    if path not in react_page_routes:
+                        return NOT_FOUND_PAGE.format(path=path), 404
+
+                    # Registered — check if browser
+                    accept = flask_request.headers.get("Accept", "")
+                    if not is_browser_request(accept):
+                        return NOT_ALLOWED_PAGE.format(path=path), 405
+
+                    # Browser + registered → serve React
+                    return send_from_directory(str(build_dir), "index.html")
+
+                # ── Normal path — serve static or index.html ──────────
+                # Try static file first
+                static_file = build_dir / full_path
+                if static_file.exists():
+                    return send_from_directory(str(build_dir), full_path)
+
+                # Fallback → index.html for React Router
+                return send_from_directory(str(build_dir), "index.html")
+
+        else:
+            @app.route("/")
+            def no_react():
+                return """
+                    <html><body style='font-family:monospace;padding:2rem;background:#111;color:#eee'>
+                    <h2>⚡ FlaskReact Running</h2>
+                    <p>No React build found.</p>
+                    <p>Run: <code>cd frontend && npm run build</code></p>
+                    </body></html>
+                """
+
+    def _setup_traceback_overlay(self):
+        app = self._app
+
+        @app.errorhandler(Exception)
+        def handle_exception(exc):
+            html = build_traceback_html(
+                error_type=type(exc).__name__,
+                error_message=str(exc),
+                traceback_text=traceback.format_exc(),
+                path=flask_request.path,
+                framework="Flask",
+            )
+            return html, 500
+
+    # ── Decorator delegation ──────────────────────────────────────────────
+
+    def _register(self, path: str, **kwargs):
+        """
+        Core registration.
+        Auto-normalizes path — adds leading slash if missing.
+        React prefix routes → tracked, no-op handler (catch_all serves response).
+        Normal routes → delegated to Flask directly.
+        """
+        # Auto-normalize: "data/status" → "/data/status"
+        if not path.startswith("/"):
+            path = "/" + path
+
+        if self._is_react_route(path):
+            self._react_page_routes.add(path)
+            # Return a decorator that accepts the function but does nothing
+            # catch_all in _setup_react_serving handles the actual response
+            def decorator(f):
+                return f  # return original function unchanged
+            return decorator
+        else:
+            return self._app.route(path, **kwargs)
+
+    def route(self, path: str, **kwargs):
+        return self._register(path, **kwargs)
+
+    def get(self, path: str, **kwargs):
+        kwargs["methods"] = ["GET"]
+        return self._register(path, **kwargs)
+
+    def post(self, path: str, **kwargs):
+        kwargs["methods"] = ["POST"]
+        return self._register(path, **kwargs)
+
+    def put(self, path: str, **kwargs):
+        kwargs["methods"] = ["PUT"]
+        return self._register(path, **kwargs)
+
+    def delete(self, path: str, **kwargs):
+        kwargs["methods"] = ["DELETE"]
+        return self._register(path, **kwargs)
+
+    def run(self, host: str = "127.0.0.1", port: int = 5000, debug: bool = False, **kwargs):
+        print(f"""
+⚡ FlaskReact running at http://{host}:{port}
+   React UI  → http://{host}:{port}/
+   API       → http://{host}:{port}/api/...
+   React pages protected by prefix: {self.react_prefix}
+        """)
+        self._app.run(host=host, port=port, debug=debug, **kwargs)

fastreact/utils.py

@@ -0,0 +1,233 @@
+import sys
+
+
+TRACEBACK_TEMPLATE = """<!DOCTYPE html>
+<html>
+<head>
+  <title>FastReact Error</title>
+  <style>
+    * {{ margin: 0; padding: 0; box-sizing: border-box; }}
+    body {{
+      background: #1a1a1a;
+      color: #e0e0e0;
+      font-family: 'Fira Code', 'Courier New', monospace;
+      padding: 2rem;
+    }}
+    .header {{
+      background: #c0392b;
+      color: white;
+      padding: 1rem 1.5rem;
+      border-radius: 8px 8px 0 0;
+      font-size: 1.1rem;
+      font-weight: bold;
+    }}
+    .error-type {{
+      background: #2d2d2d;
+      border-left: 4px solid #c0392b;
+      padding: 1rem 1.5rem;
+      font-size: 1rem;
+      color: #e74c3c;
+    }}
+    .traceback {{
+      background: #242424;
+      padding: 1.5rem;
+      white-space: pre-wrap;
+      font-size: 0.875rem;
+      line-height: 1.6;
+      border-radius: 0 0 8px 8px;
+      border: 1px solid #333;
+      color: #a8b5c8;
+    }}
+    .footer {{
+      margin-top: 1rem;
+      font-size: 0.75rem;
+      color: #555;
+      text-align: center;
+    }}
+    .pill {{
+      display: inline-block;
+      background: #2d2d2d;
+      border: 1px solid #444;
+      padding: 0.2rem 0.8rem;
+      border-radius: 999px;
+      font-size: 0.75rem;
+      margin-right: 0.5rem;
+      color: #aaa;
+    }}
+    .top-bar {{
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      margin-bottom: 1rem;
+    }}
+  </style>
+</head>
+<body>
+  <div class="top-bar">
+    <span class="pill">⚡ FastReact</span>
+    <span class="pill">🐍 Python {python_version}</span>
+    <span class="pill">🌐 {path}</span>
+    <span class="pill">{framework}</span>
+  </div>
+  <div class="header">
+    <span>🔴</span> {framework} Traceback — {error_type}
+  </div>
+  <div class="error-type">
+    {error_message}
+  </div>
+  <div class="traceback">{traceback_text}</div>
+  <div class="footer">
+    Powered by FastReact — Python errors served like React errors 🚀
+  </div>
+</body>
+</html>"""
+
+
+def build_traceback_html(
+    error_type: str,
+    error_message: str,
+    traceback_text: str,
+    path: str,
+    framework: str = "FastAPI",
+) -> str:
+    """Render the traceback HTML overlay."""
+    clean_tb = filter_traceback(traceback_text)
+    return TRACEBACK_TEMPLATE.format(
+        python_version=sys.version.split()[0],
+        path=path,
+        framework=framework,
+        error_type=error_type,
+        error_message=error_message,
+        traceback_text=clean_tb,
+    )
+
+
+def filter_traceback(full_tb: str) -> str:
+    """
+    Filter traceback to show only user code.
+    Removes internal framework lines from:
+    - site-packages (starlette, fastapi, anyio, flask, werkzeug...)
+    - fastreact internals
+    - frozen modules
+    """
+    SKIP_PATTERNS = (
+        "site-packages",
+        "<frozen ",
+        "fastreact\\core.py",
+        "fastreact/core.py",
+        "fastreact\\flask_core.py",
+        "fastreact/flask_core.py",
+    )
+
+    lines = full_tb.splitlines()
+    result = []
+    i = 0
+
+    while i < len(lines):
+        line = lines[i]
+
+        # Always keep header line
+        if line.startswith("Traceback"):
+            result.append(line)
+            i += 1
+            continue
+
+        # Final error line — no leading whitespace + has colon
+        if not line.startswith(" ") and ":" in line:
+            result.append(line)
+            i += 1
+            continue
+
+        # File line — decide keep or skip
+        if line.strip().startswith("File "):
+            is_internal = any(pat in line for pat in SKIP_PATTERNS)
+            if is_internal:
+                # Skip this File line + all following code/caret lines
+                i += 1
+                while i < len(lines):
+                    next_line = lines[i]
+                    if next_line.strip().startswith("File ") or (
+                        not next_line.startswith(" ") and ":" in next_line
+                    ):
+                        break
+                    i += 1
+                continue
+            else:
+                result.append(line)
+                i += 1
+                # Keep code + caret lines that follow
+                while i < len(lines):
+                    next_line = lines[i]
+                    if next_line.strip().startswith("File ") or (
+                        not next_line.startswith(" ") and ":" in next_line
+                    ):
+                        break
+                    result.append(next_line)
+                    i += 1
+                continue
+
+        result.append(line)
+        i += 1
+
+    # Safety: if filter removed everything, return full traceback
+    if len(result) <= 2:
+        return full_tb
+
+    return "\n".join(result)
+
+
+NOT_ALLOWED_PAGE = """<!DOCTYPE html>
+<html>
+<head><title>405 Not Allowed</title>
+<style>
+  * {{ margin:0; padding:0; box-sizing:border-box; }}
+  body {{ background:#1a1a1a; color:#e0e0e0; font-family:monospace; display:flex; align-items:center; justify-content:center; min-height:100vh; }}
+  .box {{ background:#2d2d2d; border:1px solid #444; border-radius:12px; padding:2rem 3rem; text-align:center; }}
+  .code {{ font-size:4rem; color:#e74c3c; }}
+  .msg {{ color:#aaa; margin-top:0.5rem; }}
+  .pill {{ display:inline-block; background:#1a1a1a; border:1px solid #e74c3c; color:#e74c3c; padding:0.2rem 0.8rem; border-radius:999px; font-size:0.75rem; margin-top:1rem; }}
+</style></head>
+<body>
+  <div class="box">
+    <div class="code">405</div>
+    <h2>Not Allowed</h2>
+    <p class="msg">{path} is a React route.<br>It can only be accessed from a browser.</p>
+    <div class="pill">⚡ FastReact</div>
+  </div>
+</body>
+</html>"""
+
+
+NOT_FOUND_PAGE = """<!DOCTYPE html>
+<html>
+<head><title>404 Not Found</title>
+<style>
+  * {{ margin:0; padding:0; box-sizing:border-box; }}
+  body {{ background:#1a1a1a; color:#e0e0e0; font-family:monospace; display:flex; align-items:center; justify-content:center; min-height:100vh; }}
+  .box {{ background:#2d2d2d; border:1px solid #444; border-radius:12px; padding:2rem 3rem; text-align:center; }}
+  .code {{ font-size:4rem; color:#888; }}
+  .msg {{ color:#aaa; margin-top:0.5rem; }}
+  .pill {{ display:inline-block; background:#1a1a1a; border:1px solid #555; color:#888; padding:0.2rem 0.8rem; border-radius:999px; font-size:0.75rem; margin-top:1rem; }}
+  a {{ color:#e74c3c; text-decoration:none; display:block; margin-top:1rem; }}
+</style></head>
+<body>
+  <div class="box">
+    <div class="code">404</div>
+    <h2>Page Not Found</h2>
+    <p class="msg">{path} is not a registered route.</p>
+    <a href="/">← Go Home</a>
+    <div class="pill">⚡ FastReact</div>
+  </div>
+</body>
+</html>"""
+
+
+def is_browser_request(accept_header: str) -> bool:
+    """
+    Detect if request is from a browser or a service like Postman/curl.
+    Browsers send Accept: text/html
+    Postman/curl/services send Accept: application/json or */*
+    """
+    if not accept_header:
+        return False
+    return "text/html" in accept_header