izana-pywebview 0.1.0__py3-none-any.whl

izana_pywebview/__init__.py

@@ -0,0 +1,39 @@
+# The dispatch/auth/validate/serialize/invalidation/merge logic lives in
+# izana_core.executor — this adapter has no executor module of its own,
+# only the js_api-shaped transport (bridge.py) over the shared core.
+from izana_core.executor import (
+    ErrorCode,
+    IzanaError,
+    NotFound,
+    BadRequest,
+    ValidationFailed,
+    Unauthorized,
+    Forbidden,
+    NotImplementedYet,
+    InternalError,
+    compute_invalidation,
+    compute_merges,
+    execute_function,
+)
+from izana_pywebview.bridge import Bridge, execute_call, execute_context, push
+from izana_pywebview.discovery import register_module
+
+__all__ = [
+    "Bridge",
+    "execute_call",
+    "execute_context",
+    "push",
+    "register_module",
+    "execute_function",
+    "compute_invalidation",
+    "compute_merges",
+    "ErrorCode",
+    "IzanaError",
+    "NotFound",
+    "BadRequest",
+    "ValidationFailed",
+    "Unauthorized",
+    "Forbidden",
+    "NotImplementedYet",
+    "InternalError",
+]

izana_pywebview/bridge.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any, Callable
+
+from izana_core.executor import (
+    IzanaError,
+    NotFound,
+    compute_invalidation,
+    compute_merges,
+    execute_function,
+)
+from izana_core.registry import get_context_groups, get_function
+
+
+def _error_envelope(exc: IzanaError) -> dict[str, Any]:
+    # The flat, no-status shape: {"error": true, "code", "message", "details"}.
+    # izana-fastapi's router nests this under an "error" key because HTTP
+    # already carries the status line separately; a js_api bridge has no
+    # status line, so the envelope needs `error: true` to say "this is a
+    # failure" the way a status code otherwise would — the same shape
+    # izana-base's IzanaError already documents for a status-less perimeter.
+    body: dict[str, Any] = {
+        "error": True,
+        "code": exc.code.value,
+        "message": exc.message,
+    }
+    if exc.details:
+        body["details"] = exc.details
+    return body
+
+
+async def _call(request: Any, fn_name: str, args: dict[str, Any]) -> dict[str, Any]:
+    fn_class = get_function(fn_name)
+    result = await execute_function(request, fn_name, args)
+    invalidate = compute_invalidation(fn_class, args)
+    merges = compute_merges(fn_class, args, result)
+    envelope: dict[str, Any] = {"result": result, "invalidate": invalidate}
+    if merges:
+        envelope["merge"] = merges
+    return envelope
+
+
+def execute_call(request: Any, fn_name: str, args: dict[str, Any]) -> dict[str, Any]:
+    """`fn_name` dispatched, with its invalidation/merge envelope — or the
+    error envelope, since a js_api bridge has no exception-handler
+    middleware to catch `IzanaError` the way the FastAPI adapter's router
+    does; this function is that catch, done explicitly."""
+    try:
+        return asyncio.run(_call(request, fn_name, args))
+    except IzanaError as exc:
+        return _error_envelope(exc)
+
+
+async def _bundle(
+    request: Any, fn_names: list[str], params: dict[str, Any]
+) -> dict[str, Any]:
+    return {fn: await execute_function(request, fn, params) for fn in fn_names}
+
+
+def execute_context(
+    request: Any, context_name: str, params: dict[str, Any]
+) -> dict[str, Any]:
+    """Every function in `context_name`'s group, called and bundled by
+    name — the FastAPI adapter's `GET /ctx/{name}/` without the HTTP."""
+    fn_names = get_context_groups().get(context_name)
+    if not fn_names:
+        return _error_envelope(NotFound(f"context {context_name!r} not found"))
+    try:
+        return asyncio.run(_bundle(request, fn_names, params))
+    except IzanaError as exc:
+        return _error_envelope(exc)
+
+
+def push(window: Any, context: str, params: dict[str, Any] | None = None) -> None:
+    """The reverse channel: tell the frontend kernel that `context` changed
+    without waiting for it to ask. Evaluates `window.__izana_push__(...)`
+    — the handler `pywebviewTransport()` installs — through pywebview's
+    `Window.evaluate_js`, so a background job's own publish invalidates the
+    same way a mutation's `affects=` does."""
+    window.evaluate_js(
+        f"window.__izana_push__({json.dumps(context)}, {json.dumps(params)})"
+    )
+
+
+class Bridge:
+    """What pywebview gets as (part of) `js_api`: `izana_call`/`izana_fetch`,
+    thin over `execute_call`/`execute_context`. No verb name appears here —
+    dispatch is entirely registry-driven off `fn_name`/`context_name`.
+
+    `request_factory` is the one seam a consumer supplies: whatever
+    `request` means for that app is built fresh for every call, the same
+    way a WSGI/ASGI app builds a fresh `Request` per call — the executor
+    only ever reads `request` through `_enforce_auth`, so this adapter
+    itself carries no opinion about what `request` is.
+    """
+
+    def __init__(self, request_factory: Callable[[], Any]) -> None:
+        self._request_factory = request_factory
+
+    def izana_call(self, fn: str, args: dict[str, Any] | None = None) -> dict[str, Any]:
+        return execute_call(self._request_factory(), fn, args or {})
+
+    def izana_fetch(
+        self, context: str, params: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        return execute_context(self._request_factory(), context, params or {})

izana_pywebview/discovery.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+from typing import Any
+
+from izana_core.client.function import ServerFunction
+from izana_core.registry import get_function, register
+
+
+def _members(module_path: str) -> list[tuple[str, Any]]:
+    module = importlib.import_module(module_path)
+    return [
+        (name, member)
+        for name, member in inspect.getmembers(module)
+        if not inspect.isclass(member) or member.__module__ == module.__name__
+    ]
+
+
+def register_module(module_path: str) -> None:
+    """Import `module_path` and register every `@client`-declared function it
+    defines.
+
+    `@client` alone builds the `ServerFunction` subclass but does not call
+    `register()` — every adapter's discovery does that separately (the
+    izana-django adapter's `izana_module` does the same walk this does, off
+    Django's own vendored member-lister; this is that walk without the
+    Django dependency, for the one-process, one-entry-module shape a
+    pywebview app actually has).
+
+    Idempotent: re-registering the same class under the same name (a second
+    `Host()` in a test, a stale re-import) is a no-op, mirroring
+    `register()`'s own idempotence for a same-name/same-class re-visit.
+    """
+    for name, member in _members(module_path):
+        if (
+            isinstance(member, type)
+            and issubclass(member, ServerFunction)
+            and member is not ServerFunction
+        ):
+            fn_name = getattr(member, "name", None) or member.__name__
+            if get_function(fn_name) is member:
+                continue
+            register(member, fn_name)

izana_pywebview/ir.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import sys
+
+from izana_core.ir import build_ir
+
+from izana_pywebview.discovery import register_module
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if len(args) != 1:
+        print("usage: python -m izana_pywebview.ir <module>", file=sys.stderr)
+        return 2
+
+    module_name = args[0]
+    try:
+        register_module(module_name)
+    except Exception as e:
+        print(f"failed to import {module_name!r}: {e}", file=sys.stderr)
+        return 1
+
+    sys.stdout.write(build_ir())
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

izana_pywebview-0.1.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.5
+Name: izana-pywebview
+Version: 0.1.0
+Summary: Izana PyWebView backend adapter — js_api RPC dispatch + context bundling, built on izana-core.
+License-Expression: Elastic-2.0
+Requires-Python: >=3.10
+Requires-Dist: izana-core>=0.2.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'

izana_pywebview-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+izana_pywebview/__init__.py,sha256=mLvTfWKPtOZtTsQxPBa9el_WwPRZScth3OfsZd0AZhU,968
+izana_pywebview/bridge.py,sha256=pE-5rMc5ejl64Pt6IzG-Z6rPQusHtCFPJeb9Bss70Lw,4262
+izana_pywebview/discovery.py,sha256=6Am140quYlzOW_DQNUYzalmj8qz25XEdBl70tg8blIw,1632
+izana_pywebview/ir.py,sha256=4iIe7hchv0j2H_4wt-HWldN8kcsqjGiElDrqm9FhfMI,650
+izana_pywebview/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+izana_pywebview-0.1.0.dist-info/METADATA,sha256=h64GULOh0p7J18G8nQiICYPnYQ4Z2QJiIqcu2VHM4EM,346
+izana_pywebview-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+izana_pywebview-0.1.0.dist-info/RECORD,,

izana_pywebview-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any