pyweb-stack 0.1.0__py3-none-any.whl

pyweb/sync.py

@@ -0,0 +1,118 @@
+"""Offline sync: queued mutations, LWW + version conflicts, IndexedDB-shaped log.
+
+The server holds authoritative rows ``{id: (version, data)}``. Each client
+keeps an op log while offline; on reconnect the log replays in order:
+- ``set`` with a higher version wins (last-writer-wins per field set).
+- ``delete`` tombstones a row unless a newer ``set`` arrives after it.
+- concurrent ``set``/``set`` on the same version applies the resolver
+  (default: server value wins, client op reported as conflict).
+"""
+
+from __future__ import annotations
+
+import time
+import uuid
+
+
+class Op:
+    def __init__(self, kind, row_id, data=None, *, version=0, actor="client", ts=None):
+        self.id = uuid.uuid4().hex[:12]
+        self.kind = kind  # set | delete
+        self.row_id = row_id
+        self.data = data or {}
+        self.version = version
+        self.actor = actor
+        self.ts = ts if ts is not None else time.time()
+
+    def to_dict(self):
+        return {"id": self.id, "kind": self.kind, "row": self.row_id,
+                "data": self.data, "version": self.version, "actor": self.actor}
+
+
+class SyncServer:
+    def __init__(self, resolver=None):
+        self.rows: dict[str, tuple[int, dict]] = {}
+        self.tombstones: dict[str, int] = {}
+        self.resolver = resolver or (lambda server, client: ("server", server))
+        self.conflicts: list[dict] = []
+
+    def seed(self, row_id, data, version=1):
+        self.rows[row_id] = (version, dict(data))
+
+    def apply(self, op):
+        if op.kind == "set":
+            cur = self.rows.get(op.row_id)
+            tomb_v = self.tombstones.get(op.row_id, -1)
+            if cur is None:
+                if op.version >= tomb_v:
+                    self.rows[op.row_id] = (op.version, dict(op.data))
+                    self.tombstones.pop(op.row_id, None)
+                    return "applied"
+                return "stale"
+            cur_v, cur_data = cur
+            if op.version > cur_v:
+                self.rows[op.row_id] = (op.version, dict(op.data))
+                return "applied"
+            if op.version == cur_v and op.data != cur_data:
+                winner, merged = self.resolver(cur_data, op.data)
+                self.rows[op.row_id] = (cur_v + 1, dict(merged))
+                self.conflicts.append({"row": op.row_id, "winner": winner,
+                                       "server": cur_data, "client": op.data})
+                return "conflict"
+            return "stale"
+        if op.kind == "delete":
+            cur = self.rows.get(op.row_id)
+            if cur is None:
+                return "stale"
+            cur_v, _ = cur
+            if op.version >= cur_v:
+                del self.rows[op.row_id]
+                self.tombstones[op.row_id] = op.version
+                return "applied"
+            return "stale"
+        raise ValueError(f"unknown op {op.kind!r}")
+
+    def snapshot(self):
+        return {k: {"version": v, "data": d} for k, (v, d) in self.rows.items()}
+
+
+class SyncClient:
+    """Local store with an offline queue; mirrors the IndexedDB side."""
+
+    def __init__(self, server=None):
+        self.server = server
+        self.online = True
+        self.local: dict[str, tuple[int, dict]] = {}
+        self.queue: list[Op] = []
+        self.applied: list[str] = []
+
+    def set(self, row_id, data, version=1):
+        op = Op("set", row_id, data, version=version)
+        if self.online and self.server is not None:
+            self.applied.append(self.server.apply(op))
+            self.local[row_id] = (version, dict(data))
+        else:
+            self.queue.append(op)
+            self.local[row_id] = (version, dict(data))
+        return op
+
+    def delete(self, row_id, version=1):
+        op = Op("delete", row_id, version=version)
+        if self.online and self.server is not None:
+            self.applied.append(self.server.apply(op))
+            self.local.pop(row_id, None)
+        else:
+            self.queue.append(op)
+            self.local.pop(row_id, None)
+        return op
+
+    def reconnect(self):
+        results = []
+        for op in self.queue:
+            results.append(self.server.apply(op) if self.server else "no-server")
+        n = len(self.queue)
+        self.queue.clear()
+        if self.server is not None:
+            for row_id, snap in self.server.snapshot().items():
+                self.local[row_id] = (snap["version"], dict(snap["data"]))
+        return {"replayed": n, "results": results}

pyweb/testing.py

@@ -0,0 +1,154 @@
+"""Testing helpers.
+
+* :class:`TestClient` — in-process HTTP client for a `.pyweb` app. Pages
+  render exactly as in production, ``rpc()`` goes through the real RPC
+  endpoint (validation, errors, cookies), and cookies persist across
+  calls so sessions work::
+
+      from pyweb.testing import TestClient
+
+      client = TestClient("app.pyweb")
+      assert "Todos" in client.get("/").text
+      client.rpc("login", email="a@b.c", password="secret123")
+      assert client.get("/account").status == 200
+
+* :func:`serve` — run the app on a free local port for real-browser tests
+  (e.g. Playwright)::
+
+      with serve("app.pyweb") as url:
+          page.goto(url)
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import threading
+
+from .rpc import RPCError
+
+
+class TestResponse:
+    def __init__(self, status, headers, body):
+        self.status = status
+        self.headers = headers
+        self.body = body
+
+    @property
+    def text(self):
+        return self.body.decode("utf-8", "replace")
+
+    def json(self):
+        return json.loads(self.body)
+
+    def header(self, name):
+        name = name.lower()
+        return next((v for k, v in self.headers if k.lower() == name), None)
+
+    def __repr__(self):
+        return f"<TestResponse {self.status}>"
+
+
+class TestClient:
+    __test__ = False  # not a pytest test class
+
+    def __init__(self, app="app.pyweb", *, source=None, **server_kwargs):
+        from .hosting import Site
+        if source is not None:
+            import os
+            import tempfile
+            tmp = tempfile.mkdtemp(prefix="pyweb-test-")
+            app = os.path.join(tmp, "app.pyweb")
+            with open(app, "w", encoding="utf-8") as fh:
+                fh.write(source)
+        self.site = Site(app, debug=True, **server_kwargs)
+        self.cookies = {}
+
+    @property
+    def app(self):
+        return self.site.app
+
+    def _headers(self, extra=None):
+        h = {"Host": "testserver"}
+        if self.cookies:
+            h["Cookie"] = "; ".join(f"{k}={v}" for k, v in self.cookies.items())
+        h.update(extra or {})
+        return h
+
+    def _store_cookies(self, headers):
+        for k, v in headers:
+            if k.lower() != "set-cookie":
+                continue
+            pair = v.split(";", 1)[0]
+            name, _, value = pair.partition("=")
+            if "Max-Age=0" in v or not value:
+                self.cookies.pop(name.strip(), None)
+            else:
+                self.cookies[name.strip()] = value.strip()
+
+    def request(self, method, path, body=b"", headers=None):
+        status, hdrs, raw = self.site.respond(method, path, self._headers(headers), body)
+        self._store_cookies(hdrs)
+        return TestResponse(status, hdrs, raw)
+
+    def get(self, path):
+        return self.request("GET", path)
+
+    def post(self, path, data=None, headers=None):
+        body = json.dumps(data).encode() if data is not None else b""
+        return self.request("POST", path, body, {"Content-Type": "application/json", **(headers or {})})
+
+    def rpc(self, function, /, **args):
+        """Call a server function like the browser does; raise RPCError on failure."""
+        resp = self.post(f"/__pyweb/rpc/{function}", {"args": args})
+        payload = resp.json() if resp.body else {}
+        if resp.status != 200 or "error" in payload:
+            err = payload.get("error") or {}
+            raise RPCError(err.get("code", f"http_{resp.status}"), err.get("message", ""),
+                           status=resp.status, details=err.get("details"))
+        return payload.get("result")
+
+
+@contextlib.contextmanager
+def serve(app="app.pyweb", *, host="127.0.0.1", **site_kwargs):
+    """Serve ``app`` (a `.pyweb` file or built dist) on a free port; yield its base URL."""
+    import http.server
+
+    from .hosting import Site
+    from .serve import ThreadedServer
+
+    site = Site(app, **site_kwargs)
+
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def _go(self, method, body=b""):
+            status, headers, raw = site.respond(method, self.path, dict(self.headers), body)
+            self.send_response(status)
+            for k, v in headers:
+                if k.lower() != "content-length":
+                    self.send_header(k, v)
+            self.send_header("Content-Length", str(len(raw)))
+            self.end_headers()
+            if method != "HEAD":
+                self.wfile.write(raw)
+
+        def do_GET(self):  # noqa: N802
+            self._go("GET")
+
+        def do_HEAD(self):  # noqa: N802
+            self._go("HEAD")
+
+        def do_POST(self):  # noqa: N802
+            n = int(self.headers.get("Content-Length", 0) or 0)
+            self._go("POST", self.rfile.read(n) if n else b"")
+
+        def log_message(self, *a):
+            pass
+
+    httpd = ThreadedServer((host, 0), Handler)
+    thread = threading.Thread(target=httpd.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield f"http://{host}:{httpd.server_address[1]}"
+    finally:
+        httpd.shutdown()
+        httpd.server_close()

pyweb/uploads.py

@@ -0,0 +1,94 @@
+"""Uploads: filename sanitizing, size/type validation, magic-byte
+allowlist, storage paths."""
+
+from __future__ import annotations
+
+import os
+import re
+import uuid
+
+_UNSAFE = re.compile(r"[^A-Za-z0-9._-]+")
+
+MAX_BYTES = 5 * 1024 * 1024
+
+ALLOWED_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".pdf",
+                      ".txt", ".csv"}
+
+_MAGIC_BYTES = (
+    (b"\x89PNG\r\n\x1a\n", {".png"}),
+    (b"\xff\xd8\xff", {".jpg", ".jpeg"}),
+    (b"GIF87a", {".gif"}),
+    (b"GIF89a", {".gif"}),
+    (b"RIFF", {".webp"}),
+    (b"%PDF-", {".pdf"}),
+)
+
+
+class UploadRejected(Exception):
+    """Raised when an upload fails allowlist validation."""
+
+
+class ValidatedUpload:
+    def __init__(self, filename, content):
+        self.filename = filename
+        self.content = content
+
+    @property
+    def size(self):
+        return len(self.content)
+
+
+def _is_textual(ext, content):
+    if ext not in {".txt", ".csv"}:
+        return False
+    try:
+        content.decode("utf-8")
+    except UnicodeDecodeError:
+        return False
+    return b"\x00" not in content
+
+
+def validate_content(filename, content, max_bytes=MAX_BYTES):
+    """Allowlist uploads by extension AND magic bytes; enforce size caps."""
+    if len(content) > max_bytes:
+        raise UploadRejected(
+            f"upload too large: {len(content)} > {max_bytes} bytes")
+    base = os.path.basename(filename)
+    if not base or base != filename or "/" in filename or "\\" in filename:
+        raise UploadRejected("invalid filename")
+    _, ext = os.path.splitext(base)
+    ext = ext.lower()
+    if ext not in ALLOWED_EXTENSIONS:
+        raise UploadRejected(f"extension not allowed: {ext!r}")
+    if _is_textual(ext, content):
+        return ValidatedUpload(base, content)
+    for magic, exts in _MAGIC_BYTES:
+        if ext in exts and content.startswith(magic):
+            if ext == ".webp" and b"WEBP" not in content[:16]:
+                break
+            return ValidatedUpload(base, content)
+    raise UploadRejected("content does not match extension allowlist")
+
+
+def safe_filename(name):
+    base = os.path.basename((name or "").strip())
+    base = _UNSAFE.sub("_", base).strip("._")
+    return base or "file"
+
+
+def validate_upload(*, filename, size, content_type, allowed_types=(), max_bytes=10 * 1024 * 1024):
+    errors = []
+    clean = safe_filename(filename)
+    if clean != os.path.basename(filename or "") or ".." in (filename or ""):
+        errors.append("unsafe filename")
+    if size is None or size < 0:
+        errors.append("unknown size")
+    elif size > max_bytes:
+        errors.append(f"too large (max {max_bytes} bytes)")
+    if allowed_types and content_type not in allowed_types:
+        errors.append(f"unsupported type {content_type!r}")
+    return clean, errors
+
+
+def storage_path(filename, *, prefix="uploads"):
+    return f"{prefix}/{uuid.uuid4().hex[:12]}-{safe_filename(filename)}"

pyweb_stack-0.1.0.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: pyweb-stack
+Version: 0.1.0
+Summary: Full-stack web apps in one Python file: server-rendered pages, reactive browser UI, typed RPC.
+Author-email: MaanavKrishna <67054795+MaanavKrishna@users.noreply.github.com>, Claude <noreply@anthropic.com>
+Maintainer-email: MaanavKrishna <67054795+MaanavKrishna@users.noreply.github.com>
+License: MIT
+Project-URL: Homepage, https://maanavkrishna.github.io/PyWeb/
+Project-URL: Documentation, https://maanavkrishna.github.io/PyWeb/guide.html
+Project-URL: Source, https://github.com/MaanavKrishna/PyWeb
+Project-URL: Changelog, https://github.com/MaanavKrishna/PyWeb/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/MaanavKrishna/PyWeb/issues
+Keywords: web,framework,full-stack,reactive,rpc,ssr,compiler
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: JavaScript
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]>=3.1; extra == "postgres"
+Provides-Extra: mysql
+Requires-Dist: PyMySQL>=1.1; extra == "mysql"
+Provides-Extra: redis
+Requires-Dist: redis>=5; extra == "redis"
+Provides-Extra: crypto
+Requires-Dist: cryptography>=42; extra == "crypto"
+Provides-Extra: asgi
+Requires-Dist: uvicorn>=0.30; extra == "asgi"
+Provides-Extra: all
+Requires-Dist: psycopg[binary]>=3.1; extra == "all"
+Requires-Dist: PyMySQL>=1.1; extra == "all"
+Requires-Dist: redis>=5; extra == "all"
+Requires-Dist: cryptography>=42; extra == "all"
+Requires-Dist: uvicorn>=0.30; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: playwright>=1.45; extra == "test"
+Dynamic: license-file
+
+# PyWeb
+
+**Full-stack web apps in one Python file.** Server-rendered pages,
+reactive browser UI compiled from Python, and typed calls to server
+functions, without a JavaScript toolchain.
+
+[![CI](https://github.com/MaanavKrishna/PyWeb/actions/workflows/ci.yml/badge.svg)](https://github.com/MaanavKrishna/PyWeb/actions/workflows/ci.yml)
+[![Docs](https://img.shields.io/badge/docs-maanavkrishna.github.io%2FPyWeb-0d9488)](https://maanavkrishna.github.io/PyWeb/)
+![Python](https://img.shields.io/badge/python-3.10%E2%80%933.13-3776ab)
+![PyPI](https://img.shields.io/pypi/v/pyweb-stack)
+![License](https://img.shields.io/badge/license-MIT-lightgrey)
+
+```pyweb
+from pyweb import App, server
+
+app = App(title="Guestbook")
+ENTRIES = []
+
+
+@server
+def sign(name: str) -> list:
+    ENTRIES.append(name.strip() or "anonymous")
+    return ENTRIES
+
+
+@app.page("/")
+def Home():
+    entries = list(ENTRIES)     # computed on the server per request
+    name = ""                   # bound to the input: browser state
+
+    def submit():               # compiled to JavaScript
+        entries = sign(name)    # typed RPC to the server
+        name = ""
+
+    <main>
+        <h1>Guestbook ({len(entries)})</h1>
+        <form onsubmit={submit}>
+            <input bind={name} placeholder="Your name" />
+            <button>Sign</button>
+        </form>
+        <ul>
+            for entry in entries:
+                <li>{entry}</li>
+        </ul>
+    </main>
+```
+
+```bash
+pip install pyweb-stack   # imported as `pyweb`
+pyweb dev app.pyweb        # http://localhost:8000
+```
+
+## Why PyWeb
+
+- **Interactions run in the browser.** Handlers and expressions are
+  compiled to small JavaScript modules; the server is only contacted when
+  your code calls a `@server` function. No WebSocket per user, no
+  multi-megabyte Python runtime in the browser.
+- **Every page is server-rendered.** Complete HTML on first paint, real
+  data from your database, good for SEO and slow devices.
+- **You never write an API layer.** `@server` functions get endpoints,
+  argument validation, typed errors and generated browser calls.
+- **Plain variables are state.** The compiler sees which variables your
+  handlers change and makes exactly those reactive; updates touch only
+  the DOM nodes that read them.
+- **Boundaries are checked.** Database handles, imports and secrets can't
+  leak into browser code: it's a compile error with a line number.
+  `pyweb inspect` explains where every name runs and why.
+- **Stateless servers.** Signed-cookie sessions and plain HTTP RPC scale
+  horizontally behind any load balancer. Deploy with `pyweb serve`,
+  uvicorn/gunicorn (ASGI) or the generated Dockerfile.
+
+A typical interactive page ships under 1 KB of page code plus a ~10 KB
+(gzip) runtime that's cached across pages. Pages without interactivity
+ship no JavaScript.
+
+## Is it for you?
+
+**Good fit:** internal tools, admin panels, dashboards, CRUD apps,
+small SaaS products and content sites with interactive parts, built by
+people who'd rather stay in Python.
+
+**Not a fit:** large client-heavy single-page apps that need the npm
+ecosystem (use React/Svelte/Vue), or running scientific Python in the
+browser (use Pyodide/PyScript). See the
+[comparison](https://maanavkrishna.github.io/PyWeb/introduction.html)
+and [current limitations](docs/16-limitations-roadmap.md).
+
+## Documentation
+
+| | |
+|---|---|
+| Start | [Introduction](docs/01-introduction.md) · [Quickstart](docs/02-quickstart.md) · [Tutorial](docs/03-tutorial.md) |
+| Language | [`.pyweb` files](docs/04-pyweb-files.md) · [State & reactivity](docs/05-reactivity.md) · [Python in the browser](docs/07-browser-python.md) |
+| Server | [Server functions & RPC](docs/06-server-functions.md) · [Pages & routing](docs/08-pages-routing-assets.md) · [Data](docs/09-data.md) · [Auth](docs/10-auth.md) |
+| Ship | [Testing](docs/11-testing.md) · [Deployment](docs/12-deployment.md) · [Security](docs/13-security.md) · [CLI](docs/14-cli.md) |
+| Reference | [Toolkit & stability](docs/15-toolkit.md) · [Limitations & roadmap](docs/16-limitations-roadmap.md) · [Architecture](ARCHITECTURE.md) · [Changelog](CHANGELOG.md) |
+
+The same docs are published at
+**[maanavkrishna.github.io/PyWeb](https://maanavkrishna.github.io/PyWeb/)**,
+with compiler output shown next to each example.
+
+## Examples
+
+Each runs with `pyweb dev examples/<name>/app.pyweb` and is exercised in
+a real browser by the test suite.
+
+| Example | Shows |
+|---|---|
+| [`counter`](examples/counter/app.pyweb) | signals, computed values, binding a number input |
+| [`todo`](examples/todo/app.pyweb) | components, list mutation, filters, keyed lists |
+| [`blog`](examples/blog/app.pyweb) | SQL database, server functions, route params, 404s, validation errors |
+| [`auth`](examples/auth/app.pyweb) | registration, password hashing, sessions, protected pages |
+| [`chat`](examples/chat/app.pyweb) | route params, shared server state, polling with `on_mount` |
+| [`showcase`](examples/showcase/app.pyweb) | everything on one page, with a stylesheet |
+
+## Command line
+
+```bash
+pyweb new myapp                                  # scaffold
+pyweb dev app.pyweb                              # dev server: live reload + error overlay
+pyweb inspect app.pyweb                          # where each name runs, and why
+pyweb check app.pyweb                            # compile + security checks for CI
+pyweb build app.pyweb --out dist --production    # self-contained, hashed, minified dist/
+pyweb serve dist                                 # production server (/healthz, CSP, graceful shutdown)
+```
+
+## Status
+
+PyWeb 0.1 is the first public release (beta). The language, server API,
+RPC protocol and CLI are documented and tested, and changes to them are
+announced in the changelog (see [stability](docs/15-toolkit.md#stability)). The test suite covers the
+parser, the Python→JavaScript translation (differentially, against
+CPython), the reactive runtime, server rendering, RPC, sessions, every
+example app in Chromium, and the database/Redis layers against real
+Postgres, MySQL and Redis servers, on Python 3.10–3.13.
+
+## Authors
+
+Built by [MaanavKrishna](https://github.com/MaanavKrishna) and Claude.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Security reports:
+[SECURITY.md](SECURITY.md). License: MIT.

pyweb_stack-0.1.0.dist-info/RECORD

@@ -0,0 +1,54 @@
+pyweb/__init__.py,sha256=KzWzFhfv4UGkoeYJdLGbSiDt_jH6qTfM4OgILwREQbk,1668
+pyweb/app.py,sha256=CoUeVarF7b1M5lZ82JNu4FhgAgIFuov6Ty53JGTvkho,1292
+pyweb/app_loader.py,sha256=llgmM4mjg_CtnK-3lOZHWXLGdpPeLnT-NIDcGeQ51xc,5735
+pyweb/asgi.py,sha256=9ijkJlh-ZReHV56tW7eht8lXBj6gNJsGpuAQOZJs4Yg,2776
+pyweb/auth.py,sha256=ZxBDaYExQ1BgICIVdcc2gJurhr0QU1J02jFr1J_3ePU,25878
+pyweb/bench.py,sha256=mVphqhIK4Vzqs5bwI9u2CI0Ee3YH-w5i0e0-EwyvU2U,4266
+pyweb/browser.py,sha256=JXUoxthuk7Rhd6TBvTCA0Y16zDgUdHx3EckpZ0YZqMQ,5217
+pyweb/build.py,sha256=-ba44Vt0WwNkdskjC1ugZceWQJnMztnCpv0awBl0WPU,11459
+pyweb/cache.py,sha256=unbw9-DAj9HUdH7zlbw6GeRQnBZD6vZkc20AMaY-Ohg,6222
+pyweb/context.py,sha256=CN1OutPJXFVBQaEoK6L5kyNV2rkrRTnyJuGm49aQ6UY,5780
+pyweb/css.py,sha256=q6t52iAzNu-Nq_qwraD7NJoeKmWUKhKvZhCk7YLOV_g,3834
+pyweb/decorators.py,sha256=u2OKDA43EzDvVuDItOlJVxfbuUwErZDSIIVfOSehZoY,1446
+pyweb/deploy.py,sha256=-UI4BWy0p7rH-wd6MQs_5FurKHxCu25aCcfUtDYDRZI,3340
+pyweb/forms.py,sha256=ruf0EbdsyrDHVy_LADsYD8J9PwmQO4azwJrGxmkzhzo,3988
+pyweb/hosting.py,sha256=ua5DhmJuO3cIE5xmakRvTgNwtU1WFafq6252KmxiZEI,6499
+pyweb/jobs.py,sha256=NEOVWZDk_Hn3UQ58Cgf9WyE5NUn6SHjkzjdlsNPPbsI,8909
+pyweb/live.py,sha256=U7KM7PO__sVbtm9LXAfsT8k62tx6Fuye0FHVXsrgcyM,2765
+pyweb/lsp.py,sha256=P2bktYh2aaV4vJ1XR5N7CwkoTMVJ4v2wWlALibsTeKg,8327
+pyweb/models.py,sha256=hEkyIZS8JMfajMuB9CdNRGiaKDcXVKbCA7_d4MOMFC0,8844
+pyweb/npm.py,sha256=F9HVlZyrSRGfuHGTDsDt42PdGgLNjWX2gBMEdRwxlzY,9896
+pyweb/observability.py,sha256=rGDUZrAE7fj-O25zOWWJwY5GmVX3P-OPPDZBamL2nTk,10393
+pyweb/platform.py,sha256=-T4_NCCpsFwAE5ucJtStCNxm9q-mZSHkpzBC4BTclcY,2206
+pyweb/plugins.py,sha256=ZqWbbdQeQ9-fdJIzwV6iQeQpa8wpkN8DmRq5W7b7vgM,3592
+pyweb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyweb/realtime.py,sha256=LI_NZRkhWHgsB-VLcHqnCLnsHw9zUbSkotuQgqqFAEI,6904
+pyweb/rpc.py,sha256=wvLnrrrEdv3KnVjBSEU25_PsUbL8Ugt0fMudf8HBQRI,4944
+pyweb/security.py,sha256=_zzZJRRVDxXxkQzYxgClZQO-7O1TrqBb2p8Cnmwufa4,5995
+pyweb/serve.py,sha256=ivcsGeQtmX_OgHnyo8CnjkSCkh0dMevKlr5B-jgFMzU,14419
+pyweb/ssr.py,sha256=jc1ank1-Z530tHD9sh_DMyJgXLh_e4T6NQOuw0xXBas,9956
+pyweb/sync.py,sha256=_kkwk5zQFBjrX0OdXAmXbCtct3iTR0NIIHXa4Lnbnvc,4458
+pyweb/testing.py,sha256=7-xrLWzn4n7OU_0waiAL95U-SVSx0fVd1hPJzyiscEw,5056
+pyweb/uploads.py,sha256=5ThhLKbrj75zTwKa7jt3up_dEue-Nk-FsBQiTUqx5nE,2887
+pyweb/cli/__init__.py,sha256=g2GF8xEA1csdA1f6Ns4XnpVSG1xrbQEE6ktqy8v2drs,19716
+pyweb/cli/__main__.py,sha256=ubt6XyZvcHwdjCQ90B_U4MeP-3YJduz5GWUC9yOgkrg,27
+pyweb/compiler/__init__.py,sha256=2WC2v4fzgDygNBpA4tvWEQtavMZAnnxaYskWvQ6MPFU,148
+pyweb/compiler/ast.py,sha256=Wrlq_C5V-TMuQAvSK4V517V-gM0Vonq7KYFgUTOmpE4,679
+pyweb/compiler/errors.py,sha256=ge7JsZUHNeHnP313sjUdaqxZmPnWAzQGSc03L7bt_wQ,819
+pyweb/compiler/lower.py,sha256=vg_41mfdLamqEhzR_pQOtfKKE00dv5pNfl0oxpP9pqQ,31701
+pyweb/compiler/parser.py,sha256=p7iX-wv5NWsCA_256xvaegljcN6BfGe3V6a1D3dolzg,18191
+pyweb/compiler/pipeline.py,sha256=WlvvOi3tk-kwRhmIKXsfh5g01VSHm2ycflmPCz_yUyY,6885
+pyweb/compiler/pyjs.py,sha256=tftTG6gyyqvW5RNW-2Xnc2SqMPkYHZmYAQYB_fpk32w,46312
+pyweb/compiler/rpc.py,sha256=ErOMUZqyjQ6DYQJdjcDtRM_l3aBkYhKGth1cnYCdqZ8,1348
+pyweb/compiler/codegen/__init__.py,sha256=JzX5LJwTLh_tBCH7JQG1RWgysIXbMxrh47hGkS1CuIY,250
+pyweb/compiler/codegen/ir.py,sha256=s6fPk_jNVJkINdiHg2y1bru0317alR0sOKX1zcmCowk,1563
+pyweb/db/__init__.py,sha256=YvTJYVOjY3hStIG3zztcIFOcS9SN1w08npOdUNOZOaA,22093
+pyweb/db/migrate.py,sha256=xpujP2mX1EUAiA_hZzeFW6cRtgwS07gMeiAfrmJG2H0,5419
+pyweb/runtime/browser/runtime.js,sha256=LQVDWUID09CacHHA8R1TvEbtUi4EkJgtbDnw-bwZS54,40808
+pyweb/runtime/server/__init__.py,sha256=rNr05rChG_-qMD_3wyKzuIzw1t2DqytI2qOfFj_ciBM,21019
+pyweb_stack-0.1.0.dist-info/licenses/LICENSE,sha256=r7ySlQXYhVH8rdTZibIPbmVXvvNYcHyXzndJq73l_aM,1081
+pyweb_stack-0.1.0.dist-info/METADATA,sha256=AX4SWadUjNWUpWBFD6g72MNL7rwAfZltFwU-hxWDqkg,8712
+pyweb_stack-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pyweb_stack-0.1.0.dist-info/entry_points.txt,sha256=pJMhV5m72eoRgYpY4eoJjtNpOfpUiqYK2FAtYJXGQoA,41
+pyweb_stack-0.1.0.dist-info/top_level.txt,sha256=e6Ok626FGJgHAn0XPcrrsZmXJMN7wPRXgMYbGE4R0S4,6
+pyweb_stack-0.1.0.dist-info/RECORD,,

pyweb_stack-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyweb_stack-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyweb = pyweb.cli:main

pyweb_stack-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MaanavKrishna and Claude
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyweb_stack-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyweb