PyPI - snackapp - Versions diffs - 0.1.1__py3-none-any.whl - Mend

snackapp 0.1.1__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 (24) hide show

snackapp/__init__.py +26 -0
snackapp/__main__.py +6 -0
snackapp/app.py +494 -0
snackapp/cli.py +177 -0
snackapp/config.py +76 -0
snackapp/discovery.py +162 -0
snackapp/exceptions.py +24 -0
snackapp/fields/__init__.py +15 -0
snackapp/fields/filters.py +126 -0
snackapp/fields/registry.py +236 -0
snackapp/fields/validate.py +50 -0
snackapp/provision.py +123 -0
snackapp/py.typed +0 -0
snackapp/schema.py +286 -0
snackapp/schema_sync.py +96 -0
snackapp/static/.gitkeep +0 -0
snackapp/static/assets/index-DiBbpiCA.css +1 -0
snackapp/static/assets/index-DoUWBAjL.js +40 -0
snackapp/static/index.html +13 -0
snackapp/ui.py +271 -0
snackapp-0.1.1.dist-info/METADATA +60 -0
snackapp-0.1.1.dist-info/RECORD +24 -0
snackapp-0.1.1.dist-info/WHEEL +4 -0
snackapp-0.1.1.dist-info/entry_points.txt +2 -0

snackapp/__init__.py ADDED Viewed

@@ -0,0 +1,26 @@
+"""SnackApp — Python application framework with SnackBase embedded."""
+from importlib.metadata import PackageNotFoundError, version
+from snackapp import ui
+from snackapp.app import App, Ctx, Table
+from snackapp.discovery import action, page
+from snackapp.schema import Field, Schema, rules_for
+try:
+    __version__ = version("snackapp")
+except PackageNotFoundError:
+    __version__ = "0.1.1"
+__all__ = [
+    "App",
+    "Ctx",
+    "Field",
+    "Schema",
+    "Table",
+    "action",
+    "page",
+    "rules_for",
+    "ui",
+    "__version__",
+]

snackapp/__main__.py ADDED Viewed

@@ -0,0 +1,6 @@
+"""`python -m snackapp` is equivalent to the `snackapp` console script."""
+from snackapp.cli import main
+if __name__ == "__main__":
+    main()

snackapp/app.py ADDED Viewed

@@ -0,0 +1,494 @@
+"""The App object: pages, actions, auth, and the ASGI mount."""
+from __future__ import annotations
+import inspect
+import re
+import traceback
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from fastapi import APIRouter, Cookie, FastAPI, Request, Response
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from starlette.concurrency import run_in_threadpool
+from snackapp import ui
+from snackapp.exceptions import DuplicateRouteError, ValidationError
+from snackapp.fields.registry import serialize_registry
+from snackapp.schema import CollectionDef, Schema
+STATIC = Path(__file__).parent / "static"
+def _prepare_shell(at: str) -> str:
+    """Rewrite the Vite index.html so hashed assets load from ``/_sa/static``."""
+    fallback = (
+        "<!doctype html><html><body><div id='root'></div>"
+        f"<script src='{at}/_sa/static/app.js' data-base='{at}'></script></body></html>"
+    )
+    path = STATIC / "index.html"
+    if not path.exists():
+        return fallback
+    html = path.read_text()
+    prefix = f"{at}/_sa/static"
+    html = html.replace('src="./assets/', f'src="{prefix}/assets/')
+    html = html.replace("src='./assets/", f"src='{prefix}/assets/")
+    html = html.replace('href="./assets/', f'href="{prefix}/assets/')
+    html = html.replace("href='./assets/", f"href='{prefix}/assets/")
+    if "data-base" not in html:
+        html = html.replace("<script", f'<script data-base="{at}"', 1)
+    else:
+        html = html.replace('data-base=""', f'data-base="{at}"')
+    return html
+@dataclass
+class Page:
+    path: str
+    fn: Callable[..., Any]
+    title: str
+    nav: bool
+    icon: str | None
+    regex: re.Pattern[str]
+    params: list[str]
+    order: int = 0
+    public: bool = False
+    command: bool = False
+def _compile_path(path: str) -> tuple[re.Pattern[str], list[str]]:
+    params = re.findall(r"\{(\w+)\}", path)
+    pattern = "^" + re.sub(r"\{(\w+)\}", r"(?P<\1>[^/]+)", path) + "$"
+    return re.compile(pattern), params
+def route_specificity(path: str) -> tuple[int, int]:
+    """Static segments beat parameterised ones; longer paths first."""
+    return (path.count("{"), -len(path))
+class Ctx:
+    def __init__(self, app: App, client: Any, user: dict[str, Any], query: dict[str, str]) -> None:
+        self.app = app
+        self.db = client
+        self.user = user
+        self.query = query
+        self._refresh: list[str] = []
+        self._reads: dict[str, set[str]] = {}
+        self._page_reads: set[str] = set()
+        self._wrote: set[str] = set()
+        self._redirect: str | None = None
+        self._toast: str | None = None
+    def refresh(self, *fragments: str) -> None:
+        self._refresh.extend(fragments)
+    def go(self, path: str) -> None:
+        self._redirect = path
+    def toast(self, msg: str) -> None:
+        self._toast = msg
+class Table:
+    def __init__(self, cd: CollectionDef, ctx_getter: Callable[[], Ctx]) -> None:
+        self.cd = cd
+        self.name = cd.name
+        self._ctx = ctx_getter
+    @property
+    def db(self) -> Any:
+        return self._ctx().db
+    def _read(self) -> None:
+        ctx = self._ctx()
+        ctx._page_reads.add(self.name)
+        for frag in ui.active_fragments():
+            ctx._reads.setdefault(frag, set()).add(self.name)
+    def _write(self) -> None:
+        self._ctx()._wrote.add(self.name)
+    def list(self, **params: Any) -> list[dict[str, Any]]:
+        self._read()
+        payload = _run(self.db.list(self.name, **params))
+        if isinstance(payload, dict):
+            return list(payload.get("items") or payload.get("data") or [])
+        return list(payload or [])
+    def get(self, rid: str, expand: str | None = None) -> dict[str, Any]:
+        self._read()
+        return _run(self.db.get(self.name, rid, expand=expand))
+    def create(self, **data: Any) -> dict[str, Any]:
+        self._write()
+        return _run(self.db.create(self.name, data))
+    def update(self, rid: str, **data: Any) -> dict[str, Any]:
+        self._write()
+        return _run(self.db.update(self.name, rid, data))
+    def delete(self, rid: str) -> None:
+        self._write()
+        _run(self.db.delete(self.name, rid))
+    def aggregate(self, **params: Any) -> dict[str, Any]:
+        self._read()
+        return _run(self.db.aggregate(self.name, **params))
+    def count(self, filter: str | None = None) -> int:
+        self._read()
+        payload = _run(self.db.aggregate(self.name, functions="count()", filter=filter))
+        if isinstance(payload, dict):
+            results = payload.get("results") or []
+            if results and isinstance(results[0], dict):
+                row = results[0]
+                for key in ("count", "count()"):
+                    if key in row:
+                        return int(row[key] or 0)
+                for value in row.values():
+                    if isinstance(value, (int, float)):
+                        return int(value)
+            if payload.get("total") is not None:
+                return int(payload["total"] or 0)
+            if payload.get("count") is not None:
+                return int(payload["count"] or 0)
+        return 0
+def _run(result: Any) -> Any:
+    import asyncio
+    if asyncio.iscoroutine(result):
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(result)
+        import concurrent.futures
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+            return pool.submit(asyncio.run, result).result()
+    return result
+def intersecting_fragments(
+    reads: dict[str, set[str]], wrote: set[str], page_reads: set[str]
+) -> list[str]:
+    """Fragments whose recorded reads intersect the action's wrote set."""
+    out: list[str] = []
+    for name, deps in reads.items():
+        target = deps if deps else page_reads
+        if target & wrote:
+            out.append(name)
+    return sorted(out)
+class App:
+    def __init__(self, title: str, account: str | None = None) -> None:
+        self.title = title
+        self.account = account
+        self.schema = Schema()
+        self.base_path = ""
+        self.pages: list[Page] = []
+        self.actions: dict[str, Callable[..., Any]] = {}
+        self.tables: dict[str, Table] = {}
+        import contextvars
+        self._ctx_var: contextvars.ContextVar[Ctx] = contextvars.ContextVar("sa_ctx")
+        self._host: FastAPI | None = None
+    def collection(self, name: str, *fields: dict[str, Any], **kw: Any) -> Table:
+        cd = self.schema.collection(name, *fields, **kw)
+        table = Table(cd, lambda: self._ctx_var.get())
+        self.tables[name] = table
+        return table
+    def page(
+        self,
+        path: str,
+        title: str = "",
+        nav: bool = False,
+        icon: str | None = None,
+        order: int = 0,
+        public: bool = False,
+    ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+        def deco(fn: Callable[..., Any]) -> Callable[..., Any]:
+            existing = [p for p in self.pages if p.path == path]
+            if existing:
+                raise DuplicateRouteError(
+                    f"duplicate route {path!r}: {existing[0].fn.__module__} and {fn.__module__}"
+                )
+            rx, params = _compile_path(path)
+            self.pages.append(
+                Page(
+                    path,
+                    fn,
+                    title or fn.__name__,
+                    nav,
+                    icon,
+                    rx,
+                    params,
+                    order,
+                    public,
+                )
+            )
+            self.pages.sort(key=lambda p: route_specificity(p.path))
+            return fn
+        return deco
+    def autodiscover(
+        self,
+        pages: str | Path = "pages",
+        actions: str | Path | None = "actions",
+        base: str | Path | None = None,
+    ) -> dict[str, list[str]]:
+        from snackapp.discovery import load_package
+        root = Path(base) if base else Path(self._caller_dir())
+        out = {"pages": load_package(self, root / Path(pages), "pages")}
+        if actions:
+            out["actions"] = load_package(self, root / Path(actions), "actions")
+        self.pages.sort(key=lambda p: route_specificity(p.path))
+        return out
+    @staticmethod
+    def _caller_dir() -> str:
+        for frame in inspect.stack():
+            f = frame.filename
+            if "snackapp/" not in f and not f.startswith("<"):
+                return str(Path(f).resolve().parent)
+        return str(Path.cwd())
+    def action(
+        self, fn: Callable[..., Any] | None = None, *, command: bool = False
+    ) -> Callable[..., Any]:
+        def deco(func: Callable[..., Any]) -> Callable[..., Any]:
+            setattr(func, "command", command)
+            self.actions[func.__name__] = func
+            return func
+        if fn is None:
+            return deco  # type: ignore[return-value]
+        return deco(fn)
+    def _client_for(self, token: str | None) -> Any:
+        from snackbase.embedded import create_client
+        from snackbase.infrastructure.api.app import app as host
+        return create_client(app=self._host or host, token=token, account=self.account)
+    def _match(self, path: str) -> tuple[Page, dict[str, str]] | None:
+        for page in self.pages:
+            matched = page.regex.match(path)
+            if matched:
+                return page, matched.groupdict()
+        return None
+    def _render(self, ctx: Ctx, page: Page, params: dict[str, str]) -> dict[str, Any]:
+        root, token = ui.new_tree()
+        tok2 = self._ctx_var.set(ctx)
+        try:
+            sig = inspect.signature(page.fn).parameters
+            kwargs: dict[str, Any] = {k: v for k, v in params.items() if k in sig}
+            if "ctx" in sig:
+                kwargs["ctx"] = ctx
+            page.fn(**kwargs)
+        finally:
+            ui.end_tree(token)
+            self._ctx_var.reset(tok2)
+        def stamp(node: dict[str, Any]) -> None:
+            if node.get("kind") == "fragment":
+                own = ctx._reads.get(node["name"])
+                node["deps"] = sorted(own if own else ctx._page_reads)
+            for child in node.get("children", []):
+                stamp(child)
+        stamp(root)
+        return root
+    def nav_items(self) -> list[dict[str, Any]]:
+        items = [p for p in self.pages if p.nav]
+        items.sort(key=lambda p: (p.order, p.title))
+        return [{"path": p.path, "title": p.title, "icon": p.icon} for p in items]
+    def router(self, at: str = "") -> APIRouter:
+        r = APIRouter(prefix=f"{at}/_sa")
+        @r.post("/login")
+        async def login(request: Request) -> Response:
+            body = await request.json()
+            client = self._client_for(None)
+            try:
+                payload = await client.request(
+                    "POST",
+                    "/api/v1/auth/login",
+                    json={
+                        "email": body["email"],
+                        "password": body["password"],
+                        "account": body.get("account") or self.account,
+                    },
+                )
+            except Exception as exc:
+                status = getattr(exc, "status_code", 401)
+                return JSONResponse({"error": str(exc)}, status_code=int(status) or 401)
+            token = payload.get("token") or payload.get("access_token")
+            resp = JSONResponse({"ok": True})
+            resp.set_cookie(
+                "sa_token",
+                token,
+                httponly=True,
+                samesite="lax",
+                path="/",
+            )
+            return resp
+        @r.post("/logout")
+        async def logout() -> Response:
+            resp = JSONResponse({"ok": True})
+            resp.delete_cookie("sa_token", path="/")
+            return resp
+        @r.get("/meta")
+        async def meta(sa_token: str | None = Cookie(default=None)) -> dict[str, Any]:
+            out: dict[str, Any] = {
+                "title": self.title,
+                "nav": self.nav_items(),
+                "user": None,
+                "fields": serialize_registry(),
+                "single_account": True,
+            }
+            if sa_token:
+                try:
+                    user = await self._client_for(sa_token).me()
+                    out["user"] = user
+                except Exception:
+                    pass
+            return out
+        @r.get("/view")
+        async def view(
+            path: str,
+            request: Request,
+            sa_token: str | None = Cookie(default=None),
+        ) -> Any:
+            hit = self._match(path)
+            if not hit:
+                return JSONResponse({"error": f"no page for {path}"}, status_code=404)
+            page, params = hit
+            if not page.public and not sa_token:
+                return JSONResponse({"error": "auth"}, status_code=401)
+            client = self._client_for(sa_token)
+            user: dict[str, Any] = {}
+            if sa_token:
+                try:
+                    user = await client.me()
+                except Exception:
+                    if not page.public:
+                        return JSONResponse({"error": "auth"}, status_code=401)
+            query = dict(request.query_params)
+            query.pop("path", None)
+            ctx = Ctx(self, client, user, query)
+            try:
+                tree = await run_in_threadpool(self._render, ctx, page, params)
+            except Exception as exc:
+                return JSONResponse(
+                    {
+                        "error": "render",
+                        "detail": str(exc),
+                        "trace": traceback.format_exc()[-1500:],
+                    },
+                    status_code=200,
+                )
+            return {"title": page.title, "tree": tree, "user": user}
+        @r.post("/action/{name}")
+        async def run_action(
+            name: str,
+            request: Request,
+            sa_token: str | None = Cookie(default=None),
+        ) -> Any:
+            if not sa_token:
+                return JSONResponse({"error": "auth"}, status_code=401)
+            fn = self.actions.get(name)
+            if not fn:
+                return JSONResponse({"error": f"no action {name}"}, status_code=404)
+            client = self._client_for(sa_token)
+            body = await request.json()
+            user = await client.me()
+            ctx = Ctx(self, client, user, {})
+            sig = inspect.signature(fn)
+            params_ = sig.parameters
+            has_kwargs = any(
+                p.kind is inspect.Parameter.VAR_KEYWORD for p in params_.values()
+            )
+            kwargs = {k: v for k, v in body.items() if has_kwargs or k in params_}
+            kwargs.pop("ctx", None)
+            if "ctx" in params_:
+                kwargs["ctx"] = ctx
+            def _call() -> None:
+                tok = self._ctx_var.set(ctx)
+                try:
+                    fn(**kwargs)
+                finally:
+                    self._ctx_var.reset(tok)
+            try:
+                await run_in_threadpool(_call)
+            except ValidationError as exc:
+                return JSONResponse(
+                    {"ok": False, "error": exc.message, "field": exc.field}
+                )
+            except Exception as exc:
+                return JSONResponse({"ok": False, "error": str(exc)})
+            auto = intersecting_fragments(ctx._reads, ctx._wrote, ctx._page_reads)
+            refresh = list(dict.fromkeys([*ctx._refresh, *auto]))
+            return {
+                "ok": True,
+                "refresh": refresh,
+                "wrote": sorted(ctx._wrote),
+                "redirect": ctx._redirect,
+                "toast": ctx._toast,
+            }
+        return r
+    def mount(self, api: FastAPI, at: str = "") -> FastAPI:
+        at = at.rstrip("/")
+        self.base_path = at
+        self._host = api
+        if not at:
+            api.router.routes = [
+                route for route in api.router.routes if getattr(route, "path", None) != "/"
+            ]
+        api.include_router(self.router(at))
+        if STATIC.exists():
+            api.mount(f"{at}/_sa/static", StaticFiles(directory=STATIC), name="sa_static")
+        shell = _prepare_shell(at)
+        @api.api_route(at + "/{full_path:path}", methods=["GET", "HEAD"], include_in_schema=False)
+        async def spa(full_path: str) -> Response:
+            if full_path.startswith(("api/", "_sa/")):
+                return JSONResponse({"error": "not found"}, status_code=404)
+            return HTMLResponse(
+                shell,
+                headers={"Cache-Control": "no-store"},
+            )
+        if at:
+            @api.api_route(at, methods=["GET", "HEAD"], include_in_schema=False)
+            async def spa_root() -> Response:
+                return HTMLResponse(shell, headers={"Cache-Control": "no-store"})
+        return api
+    def fastapi(self, at: str = "") -> FastAPI:
+        from snackbase.infrastructure.api.app import create_app
+        return self.mount(create_app(), at=at)

snackapp/cli.py ADDED Viewed

@@ -0,0 +1,177 @@
+"""Console script for SnackApp."""
+from __future__ import annotations
+import importlib.util
+import os
+import sys
+from importlib.metadata import version
+from pathlib import Path
+from typing import Any
+import click
+from snackapp.config import resolve
+from snackapp.exceptions import DestructiveChangeError, UnknownRevisionError
+INIT_APP = '''from snackapp import App, Field
+app = App("Demo")
+items = app.collection(
+    "items",
+    Field.text("name", required=True),
+    access="team",
+)
+'''
+INIT_MODELS = '''from snackapp import Field
+'''
+INIT_PAGE = '''from snackapp import page, ui
+@page("/", title="Home", nav=True)
+def index():
+    ui.header("Home")
+    ui.text("Edit pages/index.py to get started.")
+'''
+@click.group(invoke_without_command=True)
+@click.version_option(version=version("snackapp"), prog_name="snackapp")
+@click.pass_context
+def cli(ctx: click.Context) -> None:
+    """SnackApp — Python apps with SnackBase embedded."""
+    if ctx.invoked_subcommand is None and not ctx.resilient_parsing:
+        click.echo(ctx.get_help())
+def main() -> None:
+    cli(standalone_mode=True)
+@cli.command()
+@click.argument("name")
+def init(name: str) -> None:
+    """Scaffold a new SnackApp project."""
+    root = Path(name)
+    if root.exists() and any(root.iterdir()):
+        raise click.ClickException(f"{name} is not empty")
+    (root / "pages").mkdir(parents=True)
+    (root / "app.py").write_text(INIT_APP)
+    (root / "models.py").write_text(INIT_MODELS)
+    (root / "pages" / "index.py").write_text(INIT_PAGE)
+    (root / ".gitignore").write_text(".snackapp/\n")
+    (root / "snackapp.toml").write_text("port = 8000\n")
+    click.echo(f"Created {name}. Next: cd {name} && snackapp run")
+@cli.command()
+@click.option("--port", type=int, default=None)
+@click.option("--host", type=str, default=None)
+@click.option("--reload", is_flag=True, default=False)
+def run(port: int | None, host: str | None, reload: bool) -> None:
+    """Start the embedded SnackBase + application process."""
+    import asyncio
+    import uvicorn
+    from snackapp.provision import apply_runtime_env, provision_first_user
+    settings = resolve(cli={"port": port, "host": host, "reload": reload or None})
+    apply_runtime_env()
+    os.environ["SNACKAPP_ADMIN"] = settings.admin
+    if settings.backend_url:
+        os.environ["SNACKAPP_BACKEND_URL"] = settings.backend_url
+    app_obj = _load_app()
+    async def _boot() -> None:
+        from snackbase.infrastructure.persistence.database import init_database
+        from snackapp.schema_sync import apply_schema
+        await init_database()
+        creds = await provision_first_user()
+        if creds:
+            click.echo(
+                "First run credentials (shown once):\n"
+                f"  account:  {creds['account']}\n"
+                f"  email:    {creds['email']}\n"
+                f"  password: {creds['password']}"
+            )
+        await apply_schema(app_obj, confirm=False)
+    try:
+        asyncio.run(_boot())
+    except UnknownRevisionError as exc:
+        raise SystemExit(str(exc)) from exc
+    except DestructiveChangeError as exc:
+        raise SystemExit(str(exc)) from exc
+    asgi = app_obj.fastapi()
+    uvicorn.run(
+        asgi,
+        host=settings.host,
+        port=settings.port,
+        reload=settings.reload,
+    )
+@cli.command()
+def routes() -> None:
+    """Print the resolved route table."""
+    app_obj = _load_app()
+    for page in app_obj.pages:
+        click.echo(f"{page.path:20} {page.fn.__module__}")
+@cli.command()
+@click.option("--plan", is_flag=True, default=False)
+@click.option("--confirm", is_flag=True, default=False)
+def migrate(plan: bool, confirm: bool) -> None:
+    """Plan or apply schema migrations."""
+    from snackapp.provision import apply_runtime_env
+    apply_runtime_env()
+    app_obj = _load_app()
+    if plan:
+        diff = _plan_schema(app_obj)
+        click.echo(diff)
+        return
+    _sync_schema(app_obj, confirm=confirm)
+def _load_app() -> Any:
+    path = Path("app.py")
+    if not path.exists():
+        raise click.ClickException("no app.py in the current directory")
+    spec = importlib.util.spec_from_file_location("user_app", path)
+    if spec is None or spec.loader is None:
+        raise click.ClickException("cannot load app.py")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["user_app"] = module
+    spec.loader.exec_module(module)
+    app_obj = getattr(module, "app", None)
+    if app_obj is None:
+        raise click.ClickException("app.py must define `app = App(...)`")
+    pages = Path("pages")
+    if pages.exists():
+        app_obj.autodiscover(pages="pages", actions="actions" if Path("actions").exists() else None)
+    return app_obj
+def _plan_schema(app_obj: Any) -> dict[str, Any]:
+    import asyncio
+    from snackapp.schema_sync import current_schemas, plan_schema
+    return plan_schema(app_obj, asyncio.run(current_schemas()))
+def _sync_schema(app_obj: Any, *, confirm: bool) -> None:
+    import asyncio
+    from snackapp.schema_sync import apply_schema
+    asyncio.run(apply_schema(app_obj, confirm=confirm))