pyweb-stack 0.1.0__py3-none-any.whl

pyweb/__init__.py

@@ -0,0 +1,71 @@
+"""PyWeb — Python from browser to database."""
+
+from .app import App
+from .models import Email, Model
+from . import auth, cache, jobs, realtime, security, observability, forms, testing
+from . import sync, deploy, uploads, lsp, live
+from . import browser as browser_api
+from . import build, css, plugins, platform
+from .jobs import task
+from .context import NotFound, redirect, request, session
+from .rpc import RPCError
+from .decorators import component, edge, server, worker
+
+__all__ = [
+    "App",
+    "request",
+    "session",
+    "redirect",
+    "NotFound",
+    "RPCError",
+    "component",
+    "edge",
+    "server",
+    "worker",
+    "Email",
+    "Model",
+    "task",
+    "auth",
+    "cache",
+    "jobs",
+    "realtime",
+    "security",
+    "observability",
+    "forms",
+    "testing",
+    "sync",
+    "live",
+    "deploy",
+    "uploads",
+    "lsp",
+    "browser_api",
+    "build",
+    "css",
+    "plugins",
+    "platform",
+]
+
+def _version():
+    """Single source of truth: installed dist metadata, else pyproject."""
+    try:
+        from importlib.metadata import version, PackageNotFoundError
+        try:
+            return version("pyweb-stack")
+        except PackageNotFoundError:
+            pass
+    except ImportError:  # pragma: no cover - ancient Python
+        pass
+    import os
+    import re
+    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    try:
+        with open(os.path.join(root, "pyproject.toml")) as fh:
+            m = re.search(r'^version\s*=\s*"([^"]+)"', fh.read(), re.M)
+            if m:
+                return m.group(1)
+    except OSError:
+        pass
+    return "0.0.0+unknown"
+
+
+__version__ = _version()

pyweb/app.py

@@ -0,0 +1,37 @@
+"""Application object: page registry and configuration."""
+
+from __future__ import annotations
+
+
+class App:
+    def __init__(self, database=None, cache=None, auth=None, plugins=(), *,
+                 title="PyWeb", stylesheets=(), lang="en"):
+        self.title = title
+        self.stylesheets = list(stylesheets)
+        self.lang = lang
+        self.database = database
+        self.cache = cache
+        self.auth = auth
+        self.pages: list[tuple[str, str, dict]] = []
+        from pyweb.plugins import Registry
+        self.plugins = Registry()
+        for plugin in plugins:
+            self.use(plugin)
+
+    def page(self, route, *, title=None, render="server"):
+        def deco(fn):
+            self.pages.append((route, fn.__name__, {"render": render, "title": title}))
+            fn.__pyweb_route__ = route
+            fn.__pyweb_title__ = title
+            fn.__pyweb_render__ = render
+            return fn
+
+        return deco
+
+    def use(self, plugin):
+        """Attach a :class:`pyweb.plugins.Plugin`; merges its routes."""
+        self.plugins.add(plugin)
+        for route, fn in plugin.routes:
+            self.pages.append((route, fn.__name__, {"render": "server",
+                                                   "plugin": plugin.name}))
+        return plugin

pyweb/app_loader.py

@@ -0,0 +1,139 @@
+"""Load a `.pyweb` app for serving: compile, execute the Python half,
+wire ``@server`` functions to RPC, and render pages per request.
+
+``pyweb dev``, ``pyweb serve`` and the ASGI adapter all go through
+:class:`LoadedApp`, so the three behave identically.
+"""
+
+from __future__ import annotations
+
+import ast
+import copy
+import inspect
+import os
+import sys
+import types
+
+from .compiler import compile_source
+from .compiler import parser as P
+from .compiler.lower import is_ui_stmt
+from .context import NotFound, Redirect
+from .ssr import Renderer, page_html
+
+STATE_PREFIX = "__pyweb_state_"
+
+
+def _state_function(fn):
+    """Copy a page/component function into one that returns its locals.
+
+    Markup placeholders are dropped; an explicit ``return`` (e.g.
+    ``return redirect("/login")``) still returns early.
+    """
+    new = copy.deepcopy(fn)
+    new.name = STATE_PREFIX + fn.name
+    new.decorator_list = []
+    body = [s for s in new.body if not is_ui_stmt(s)]
+    ret = ast.Return(value=ast.Call(func=ast.Name(id="locals", ctx=ast.Load()), args=[], keywords=[]))
+    body.append(ret)
+    new.body = body
+    ast.fix_missing_locations(new)
+    return new
+
+
+class LoadedApp:
+    def __init__(self, path=None, *, source=None, filename=None, asset_urls=None,
+                 stylesheets=None):
+        if source is None:
+            with open(path, encoding="utf-8") as fh:
+                source = fh.read()
+        self.path = path
+        self.filename = filename or path or "app.pyweb"
+        self.source = source
+        self.asset_urls = dict(asset_urls or {})
+        self.extra_stylesheets = list(stylesheets or [])
+        self.compiled = compile_source(source, filename=self.filename)
+        self.ctx = self.compiled["context"]
+        self.module = self._exec()
+        self.rpc = {}
+        for spec in self.compiled["rpc"]:
+            fn = self.module.__dict__.get(spec["name"])
+            if callable(fn):
+                self.rpc[spec["name"]] = fn
+        app_obj = next((v for v in self.module.__dict__.values()
+                        if type(v).__name__ == "App" and type(v).__module__.startswith("pyweb")), None)
+        self.app = app_obj
+        self.title = getattr(app_obj, "title", None) or "PyWeb"
+        self.stylesheets = list(getattr(app_obj, "stylesheets", []) or []) + self.extra_stylesheets
+        self.lang = getattr(app_obj, "lang", "en") or "en"
+
+    # ----------------------------------------------------------- module
+    def _exec(self):
+        py_source, _ui = P.split_sources(self.source)
+        tree = ast.parse(py_source, filename=self.filename)
+        infos = [p["info"] for p in self.compiled["pages"].values()]
+        infos += list(self.compiled["components"].values())
+        for info in infos:
+            tree.body.append(_state_function(info.node))
+        stem = os.path.splitext(os.path.basename(self.filename))[0] or "app"
+        mod = types.ModuleType(f"pyweb_app_{stem}")
+        mod.__file__ = os.path.abspath(self.filename) if self.path else self.filename
+        mod.__dict__["__pyweb_ui__"] = lambda *_a: None
+        app_dir = os.path.dirname(os.path.abspath(self.path)) if self.path else None
+        if app_dir and app_dir not in sys.path:
+            sys.path.insert(0, app_dir)
+        sys.modules[mod.__name__] = mod
+        exec(compile(tree, self.filename, "exec"), mod.__dict__)  # noqa: S102 - the app itself
+        return mod
+
+    # -------------------------------------------------------- rendering
+    def _component_state(self, name, props):
+        info = self.compiled["components"][name]
+        fn = self.module.__dict__[STATE_PREFIX + name]
+        env = fn(**{k: v for k, v in props.items() if k in info.params})
+        return info.ui, env
+
+    def renderer(self):
+        return Renderer(self.module.__dict__, component_state=self._component_state, strict=True)
+
+    def coerce_params(self, page_name, raw):
+        fn = self.module.__dict__[STATE_PREFIX + page_name]
+        out = {}
+        for pname, param in inspect.signature(fn).parameters.items():
+            if pname not in raw:
+                continue
+            ann = param.annotation
+            value = raw[pname]
+            try:
+                if ann in (int, "int"):
+                    value = int(value)
+                elif ann in (float, "float"):
+                    value = float(value)
+            except ValueError:
+                raise NotFound(f"{pname}={value!r}") from None
+            out[pname] = value
+        return out
+
+    def render(self, page_name, params=None):
+        """Return ``html`` (str) or a :class:`~pyweb.context.Redirect`."""
+        page = self.compiled["pages"][page_name]
+        info = page["info"]
+        fn = self.module.__dict__[STATE_PREFIX + page_name]
+        args = self.coerce_params(page_name, params or {})
+        result = fn(**args)
+        if isinstance(result, Redirect):
+            return result
+        if not isinstance(result, dict):
+            raise TypeError(f"page {page_name}() returned {type(result).__name__}; pages may only "
+                            "return redirect(...)")
+        env = dict(result)
+        body = self.renderer().render(info.ui, env)
+        state = {k: env.get(k) for k in info.sent}
+        js_url = self.asset_urls.get(page_name)
+        if js_url is None and page["js"]:
+            js_url = page["js_url"]
+        title = info.title or self.title
+        if callable(getattr(self.app, "title_for", None)):
+            title = self.app.title_for(page_name) or title
+        return page_html(name=page_name, title=title, body=body, state=state,
+                         js_url=js_url if page["js"] else None, css_urls=self.stylesheets,
+                         lang=self.lang)

pyweb/asgi.py

@@ -0,0 +1,71 @@
+"""ASGI adapter: run a PyWeb app under uvicorn, hypercorn or gunicorn.
+
+::
+
+    # app_asgi.py
+    from pyweb.asgi import create_app
+    app = create_app("app.pyweb")        # or a built "dist" directory
+
+    $ uvicorn app_asgi:app --workers 4
+
+Page rendering and RPC calls are synchronous Python, so each request
+runs in a worker thread (``asyncio.to_thread``) and never blocks the
+event loop. Request bodies are capped at ``max_body`` bytes (413).
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from .hosting import Site
+
+
+def create_app(target="app.pyweb", *, debug=False, max_body=1_048_576, **server_kwargs):
+    """Return an ASGI 3 application serving ``target`` (a `.pyweb` file or dist dir)."""
+    site = Site(target, debug=debug, max_body=max_body, **server_kwargs)
+
+    async def app(scope, receive, send):
+        if scope["type"] == "lifespan":
+            while True:
+                msg = await receive()
+                if msg["type"] == "lifespan.startup":
+                    await send({"type": "lifespan.startup.complete"})
+                elif msg["type"] == "lifespan.shutdown":
+                    await send({"type": "lifespan.shutdown.complete"})
+                    return
+        if scope["type"] != "http":
+            return
+        chunks, size, too_big = [], 0, False
+        while True:
+            msg = await receive()
+            if msg["type"] == "http.disconnect":
+                return
+            part = msg.get("body", b"")
+            size += len(part)
+            if size > max_body:
+                too_big = True
+            elif part:
+                chunks.append(part)
+            if not msg.get("more_body"):
+                break
+        headers = {}
+        for k, v in scope.get("headers", []):
+            name = k.decode("latin-1").title()
+            headers[name] = v.decode("latin-1")
+        path = scope.get("path", "/")
+        if scope.get("query_string"):
+            path += "?" + scope["query_string"].decode("latin-1")
+        if too_big:
+            status, hdrs, body = 413, [("Content-Type", "application/json")], \
+                b'{"error": {"code": "http_413", "message": "request body too large"}}'
+        else:
+            status, hdrs, body = await asyncio.to_thread(
+                site.respond, scope.get("method", "GET"), path, headers, b"".join(chunks))
+        raw_headers = [(k.lower().encode("latin-1"), v.encode("latin-1")) for k, v in hdrs]
+        if not any(k == b"content-length" for k, _ in raw_headers):
+            raw_headers.append((b"content-length", str(len(body)).encode()))
+        await send({"type": "http.response.start", "status": status, "headers": raw_headers})
+        await send({"type": "http.response.body", "body": body})
+
+    app.site = site
+    return app