PyPI - astris-python - Versions diffs - 0.1.0__py3-none-any.whl - Mend

astris-python 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

astris/__init__.py +7 -0
astris/assets/favicon.ico +0 -0
astris/auth/__init__.py +29 -0
astris/auth/installer.py +512 -0
astris/auth/session.py +241 -0
astris/cli.py +421 -0
astris/config.py +50 -0
astris/database/__init__.py +28 -0
astris/database/migrations.py +259 -0
astris/database/session.py +108 -0
astris/http/__init__.py +25 -0
astris/http/static.py +31 -0
astris/inertia/__init__.py +8 -0
astris/inertia/exceptions.py +133 -0
astris/inertia/response.py +99 -0
astris/inertia/shared.py +176 -0
astris/inertia/vite.py +89 -0
astris/installer.py +595 -0
astris/kernel.py +230 -0
astris/py.typed +0 -0
astris/routing/__init__.py +31 -0
astris/routing/router.py +38 -0
astris/security/__init__.py +3 -0
astris/security/csrf.py +100 -0
astris_python-0.1.0.dist-info/METADATA +241 -0
astris_python-0.1.0.dist-info/RECORD +29 -0
astris_python-0.1.0.dist-info/WHEEL +4 -0
astris_python-0.1.0.dist-info/entry_points.txt +5 -0
astris_python-0.1.0.dist-info/licenses/LICENSE +21 -0

astris/inertia/response.py ADDED Viewed

@@ -0,0 +1,99 @@
+import html
+import json
+from pathlib import Path
+from typing import Any
+from fastapi import Request, Response
+from starlette.responses import HTMLResponse, JSONResponse
+from starlette.types import Receive, Scope, Send
+from astris.inertia.shared import resolve_shared_props
+from astris.inertia.vite import get_vite_tags
+class InertiaResponse(Response):
+    """Inertia response handler returning JSON on dynamic visits and HTML on initial load."""
+    def __init__(
+        self,
+        request: Request,
+        component: str,
+        props: dict[str, Any] | None = None,
+        root_template: str = "resources/views/root.html",
+        status_code: int = 200,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        self.request = request
+        self.component = component
+        self.props = props or {}
+        self.root_template = root_template
+        self.status_code = status_code
+        self._custom_headers = headers or {}
+        super().__init__(status_code=status_code)
+    async def __call__(
+        self,
+        scope: Scope,
+        receive: Receive,
+        send: Send,
+    ) -> None:
+        is_inertia = self.request.headers.get("X-Inertia") == "true"
+        shared_props = await resolve_shared_props(self.request)
+        merged_props = {**shared_props, **self.props}
+        page_data = {
+            "component": self.component,
+            "props": merged_props,
+            "url": str(self.request.url.path),
+            "version": "",
+        }
+        if is_inertia:
+            response: Response = JSONResponse(
+                content=page_data,
+                status_code=self.status_code,
+                headers={
+                    "X-Inertia": "true",
+                    "Vary": "X-Inertia",
+                    **self._custom_headers,
+                },
+            )
+        else:
+            template_path = Path.cwd() / self.root_template
+            vite_tags = get_vite_tags(base_path=Path.cwd())
+            if not template_path.exists():
+                content = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Astris App</title>
+</head>
+<body>
+    <div id="app" data-page="{html.escape(json.dumps(page_data))}"></div>
+    {vite_tags}
+</body>
+</html>"""
+            else:
+                raw_html = template_path.read_text(encoding="utf-8")
+                escaped_page = html.escape(json.dumps(page_data))
+                content = raw_html.replace(
+                    "@inertia", f'<div id="app" data-page="{escaped_page}"></div>'
+                )
+                if "@vite" in content:
+                    content = content.replace("@vite", vite_tags)
+            response = HTMLResponse(
+                content=content,
+                status_code=self.status_code,
+                headers=self._custom_headers,
+            )
+        if self.request.cookies.get("_inertia_flash"):
+            response.delete_cookie(key="_inertia_flash", path="/")
+        if self.request.cookies.get("_inertia_errors"):
+            response.delete_cookie(key="_inertia_errors", path="/")
+        await response(scope, receive, send)

astris/inertia/shared.py ADDED Viewed

@@ -0,0 +1,176 @@
+import inspect
+import json
+from collections.abc import Callable
+from typing import Any
+from urllib.parse import quote, unquote
+from fastapi import Request
+from starlette.datastructures import MutableHeaders
+from starlette.responses import Response
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+# Global registry for shared prop factories
+_SHARED_PROPS: dict[str, Any] = {}
+def share(
+    key_or_dict: str | dict[str, Any] | Callable[[Request], dict[str, Any]],
+    value: Any = None,
+) -> None:
+    """Register global shared props that will be injected into every Inertia response.
+    Can be called with:
+    - share("app_name", "My App")
+    - share({"app_name": "My App", "version": "1.0.0"})
+    - share(lambda request: {"auth": {"user": getattr(request.state, "user", None)}})
+    """
+    if callable(key_or_dict) and value is None:
+        _SHARED_PROPS[f"__callable_{id(key_or_dict)}"] = key_or_dict
+    elif isinstance(key_or_dict, dict):
+        for k, v in key_or_dict.items():
+            _SHARED_PROPS[str(k)] = v
+    elif isinstance(key_or_dict, str):
+        _SHARED_PROPS[key_or_dict] = value
+def flash(
+    target: Request | Response,
+    category: str,
+    message: str,
+) -> None:
+    """Flash a session message (e.g. 'success', 'error', 'info') to the next Inertia response."""
+    if isinstance(target, Request):
+        # Attach to request state for current response or session
+        if not hasattr(target.state, "flash_messages"):
+            target.state.flash_messages = {}
+        target.state.flash_messages[category] = message
+        if hasattr(target, "session"):
+            session_flashes = target.session.get("_flash", {})
+            session_flashes[category] = message
+            target.session["_flash"] = session_flashes
+    elif isinstance(target, Response):
+        # Attach cookie-based flash for redirect responses
+        cookie_flashes = {category: message}
+        target.set_cookie(
+            key="_inertia_flash",
+            value=quote(json.dumps(cookie_flashes)),
+            path="/",
+            httponly=True,
+            samesite="lax",
+        )
+class FlashMiddleware:
+    """Middleware that persists request.state.flash_messages across redirect cycles."""
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+        request = Request(scope)
+        async def send_wrapper(message: Message) -> None:
+            if message["type"] == "http.response.start":
+                flashes = getattr(request.state, "flash_messages", None)
+                if flashes and not hasattr(request, "session"):
+                    headers = MutableHeaders(scope=message)
+                    cookie_val = quote(json.dumps(flashes))
+                    cookie_str = (
+                        f"_inertia_flash={cookie_val}; Path=/; SameSite=lax; HttpOnly"
+                    )
+                    headers.append("set-cookie", cookie_str)
+            await send(message)
+        await self.app(scope, receive, send_wrapper)
+async def resolve_shared_props(request: Request) -> dict[str, Any]:
+    """Evaluate and resolve all global and request-scoped shared props."""
+    user = getattr(request.state, "user", None)
+    if user is None and hasattr(request, "session"):
+        user = request.session.get("user_data")
+        if user is None and "user_id" in request.session:
+            user = {"id": request.session.get("user_id")}
+    resolved: dict[str, Any] = {
+        "errors": {},
+        "flash": {},
+        "auth": {"user": user},
+    }
+    # 1. Resolve global registry
+    for key, val in _SHARED_PROPS.items():
+        if key.startswith("__callable_") and callable(val):
+            res = val(request)
+            if inspect.isawaitable(res):
+                res = await res
+            if isinstance(res, dict):
+                resolved.update(res)
+        elif callable(val):
+            res = val(request)
+            if inspect.isawaitable(res):
+                res = await res
+            resolved[key] = res
+        else:
+            resolved[key] = val
+    # 2. Resolve request.state shared props if set by middleware
+    state_shared = getattr(request.state, "inertia_shared_props", None)
+    if isinstance(state_shared, dict):
+        resolved.update(state_shared)
+    # 3. Resolve flash messages
+    flash_messages: dict[str, str] = {}
+    # Check request.state
+    state_flashes = getattr(request.state, "flash_messages", None)
+    if isinstance(state_flashes, dict):
+        flash_messages.update(state_flashes)
+    # Check session if available
+    if hasattr(request, "session"):
+        session_flashes = request.session.pop("_flash", None)
+        if isinstance(session_flashes, dict):
+            flash_messages.update(session_flashes)
+    # Check cookie fallback
+    cookie_flash = request.cookies.get("_inertia_flash")
+    if cookie_flash:
+        try:
+            parsed = json.loads(unquote(cookie_flash))
+            if isinstance(parsed, dict):
+                flash_messages.update(parsed)
+        except json.JSONDecodeError:
+            pass
+    resolved["flash"] = flash_messages
+    # 4. Resolve session / cookie flashed validation errors
+    errors: dict[str, Any] = {}
+    if hasattr(request, "session"):
+        session_errors = request.session.pop("_errors", None)
+        if isinstance(session_errors, dict):
+            errors.update(session_errors)
+    state_errors = getattr(request.state, "errors", None)
+    if isinstance(state_errors, dict):
+        errors.update(state_errors)
+    cookie_errors = request.cookies.get("_inertia_errors")
+    if cookie_errors:
+        try:
+            parsed_errors = json.loads(unquote(cookie_errors))
+            if isinstance(parsed_errors, dict):
+                errors.update(parsed_errors)
+        except json.JSONDecodeError:
+            pass
+    if errors:
+        resolved["errors"] = errors
+    return resolved

astris/inertia/vite.py ADDED Viewed

@@ -0,0 +1,89 @@
+import json
+import socket
+from pathlib import Path
+from urllib.parse import urlparse
+def is_vite_running(url: str = "http://localhost:5173", timeout: float = 0.05) -> bool:
+    """Check if the Vite dev server is reachable."""
+    parsed = urlparse(url)
+    host = parsed.hostname or "127.0.0.1"
+    port = parsed.port or 5173
+    try:
+        with socket.create_connection((host, port), timeout=timeout):
+            return True
+    except (OSError, TimeoutError):
+        return False
+def get_vite_tags(
+    entry: str = "resources/js/app.ts",
+    base_path: Path | None = None,
+    vite_dev_url: str = "http://localhost:5173",
+) -> str:
+    """Generate script and link tags by detecting active Vite dev server or parsing public/build/.vite/manifest.json."""
+    base = base_path or Path.cwd()
+    # 1. Check for hot file (e.g., public/hot) or active Vite dev server
+    hot_file = base / "public" / "hot"
+    dev_url = vite_dev_url
+    if hot_file.exists():
+        dev_url = hot_file.read_text(encoding="utf-8").strip()
+    if is_vite_running(dev_url):
+        clean_url = dev_url.rstrip("/")
+        clean_entry = entry.lstrip("/")
+        return (
+            f"<!-- Vite Dev Server Scripts -->\n"
+            f'<script type="module" src="{clean_url}/@vite/client"></script>\n'
+            f'<script type="module" src="{clean_url}/{clean_entry}"></script>'
+        )
+    # 2. Parse production manifest from public/build/.vite/manifest.json or public/build/manifest.json
+    manifest_paths = [
+        base / "public" / "build" / ".vite" / "manifest.json",
+        base / "public" / "build" / "manifest.json",
+    ]
+    manifest_data: dict[str, dict] | None = None
+    for manifest_path in manifest_paths:
+        if manifest_path.exists():
+            try:
+                manifest_data = json.loads(manifest_path.read_text(encoding="utf-8"))
+                break
+            except (json.JSONDecodeError, OSError):
+                continue
+    if manifest_data:
+        clean_entry = entry.lstrip("/")
+        entry_info = manifest_data.get(clean_entry)
+        if not entry_info:
+            for key, val in manifest_data.items():
+                if key.endswith(clean_entry) or val.get("src") == clean_entry:
+                    entry_info = val
+                    break
+        if entry_info:
+            tags = ["<!-- Production Vite Assets -->"]
+            # CSS links
+            for css_file in entry_info.get("css", []):
+                tags.append(
+                    f'<link rel="stylesheet" href="/build/{css_file.lstrip("/")}">'
+                )
+            # JS script
+            js_file = entry_info.get("file", "")
+            if js_file:
+                tags.append(
+                    f'<script type="module" src="/build/{js_file.lstrip("/")}"></script>'
+                )
+            return "\n".join(tags)
+    # 3. Fallback if neither active dev server nor manifest is found
+    clean_url = vite_dev_url.rstrip("/")
+    clean_entry = entry.lstrip("/")
+    return (
+        f"<!-- Vite Assets (Fallback) -->\n"
+        f'<script type="module" src="{clean_url}/@vite/client"></script>\n'
+        f'<script type="module" src="{clean_url}/{clean_entry}"></script>'
+    )