tigrbl 0.3.5.dev5__tar.gz → 0.3.6.dev1__tar.gz

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl
-Version: 0.3.5.dev5
+Version: 0.3.6.dev1
 Summary: A modern pure ASGI/WSGI Python framework for building schema-first REST and JSON-RPC APIs with SQLAlchemy models, typed validation, lifecycle hooks, and engine extension support.
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -189,7 +189,7 @@ v
 HTTP Request
 |
 v
-FastAPI Router
+ASGI Router
 |
 v
 Tigrbl Runtime
@@ -720,6 +720,30 @@ async def decorated_create(payload, *, db=None):
     ...
 ```
 
+### Swarmauri class + Tigrbl lifecycle integration 🧬
+
+If you need to run concrete Swarmauri classes inside Tigrbl's runtime, see:
+
+* [`examples/swarmauri_tigrbl_bridge.py`](./examples/swarmauri_tigrbl_bridge.py)
+* [`examples/swarmauri_tigrbl_bridge_smooth.py`](./examples/swarmauri_tigrbl_bridge_smooth.py)
+
+The bridge examples cover two integration styles:
+
+* **Factory + schema-rich envelope** (`swarmauri_tigrbl_bridge.py`)
+  * Swarmauri Pydantic JSON workflows (`model_validate_json`, `model_dump_json`,
+    `model_json_schema`) with `HumanMessage`.
+  * A Swarmauri `Factory` invocation during `PRE_HANDLER` via `hook_ctx`.
+  * Tigrbl default verbs (`create`, `get`, `list`, `update`, `delete`) plus a custom op.
+  * `engine_ctx` at model and operation scope.
+  * Generated OpenAPI and OpenRPC documents mounted from the same model bindings.
+
+* **Smoother direct-model flow** (`swarmauri_tigrbl_bridge_smooth.py`)
+  * Uses hooks + default `create` persistence to normalize Swarmauri payloads.
+  * Adds a `Conversation` table with a persisted one-to-many relationship to messages.
+  * Avoids extra `json_schema` fields in request/response payload contracts.
+  * Returns `HumanMessage.model_validate_json(...)` directly from a custom op.
+  * Uses the concrete model classes themselves to derive input/output schema docs.
+
 ## Glossary 📖
 
 1. Tables

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/README.md

@@ -156,7 +156,7 @@ v
 HTTP Request
 |
 v
-FastAPI Router
+ASGI Router
 |
 v
 Tigrbl Runtime
@@ -687,6 +687,30 @@ async def decorated_create(payload, *, db=None):
     ...
 ```
 
+### Swarmauri class + Tigrbl lifecycle integration 🧬
+
+If you need to run concrete Swarmauri classes inside Tigrbl's runtime, see:
+
+* [`examples/swarmauri_tigrbl_bridge.py`](./examples/swarmauri_tigrbl_bridge.py)
+* [`examples/swarmauri_tigrbl_bridge_smooth.py`](./examples/swarmauri_tigrbl_bridge_smooth.py)
+
+The bridge examples cover two integration styles:
+
+* **Factory + schema-rich envelope** (`swarmauri_tigrbl_bridge.py`)
+  * Swarmauri Pydantic JSON workflows (`model_validate_json`, `model_dump_json`,
+    `model_json_schema`) with `HumanMessage`.
+  * A Swarmauri `Factory` invocation during `PRE_HANDLER` via `hook_ctx`.
+  * Tigrbl default verbs (`create`, `get`, `list`, `update`, `delete`) plus a custom op.
+  * `engine_ctx` at model and operation scope.
+  * Generated OpenAPI and OpenRPC documents mounted from the same model bindings.
+
+* **Smoother direct-model flow** (`swarmauri_tigrbl_bridge_smooth.py`)
+  * Uses hooks + default `create` persistence to normalize Swarmauri payloads.
+  * Adds a `Conversation` table with a persisted one-to-many relationship to messages.
+  * Avoids extra `json_schema` fields in request/response payload contracts.
+  * Returns `HumanMessage.model_validate_json(...)` directly from a custom op.
+  * Uses the concrete model classes themselves to derive input/output schema docs.
+
 ## Glossary 📖
 
 1. Tables

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tigrbl"
-version = "0.3.5.dev5"
+version = "0.3.6.dev1"
 description = "A modern pure ASGI/WSGI Python framework for building schema-first REST and JSON-RPC APIs with SQLAlchemy models, typed validation, lifecycle hooks, and engine extension support."
 license = "Apache-2.0"
 readme = "README.md"

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/README.md

@@ -14,7 +14,7 @@ DB = engine("sqlite+aiosqlite:///./app.db")
 app = TigrblApp(engine=DB)
 ```
 
-Use `DB.get_db` as the FastAPI dependency for acquiring sessions and avoid
+Use `DB.get_db` as the framework dependency for acquiring sessions and avoid
 exporting custom `get_async_db` helpers.
 
 These rules apply to all first-party applications, including

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/api/_api.py

@@ -29,7 +29,7 @@ class Api(APISpec, Router):
 
     @property
     def router(self) -> "Api":  # pragma: no cover - simple alias
-        """Mirror FastAPI-style router access for API instances."""
+        """Mirror ASGI-style router access for API instances."""
         return self
 
     def __init__(

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/api/tigrbl_api.py

@@ -31,6 +31,11 @@ from ..bindings.model import rebind as _rebind, bind as _bind
 from ..bindings.rest import build_router_and_attach as _build_router_and_attach
 from ..transport import mount_jsonrpc as _mount_jsonrpc
 from ..system import mount_diagnostics as _mount_diagnostics
+from ..system import mount_lens as _mount_lens
+from ..system import mount_openapi as _mount_openapi
+from ..system import mount_openrpc as _mount_openrpc
+from ..system import build_openrpc_spec as _build_openrpc_spec
+from ..system.favicon import mount_favicon
 from ..op import get_registry, OpSpec
 from ..app._model_registry import initialize_model_registry
 
@@ -58,6 +63,8 @@ class TigrblApi(_Api):
     _optional_authn_dep: Any = None
     _allow_anon_ops: set[str] = set()
 
+    mount_favicon = mount_favicon
+
     def __init__(
         self,
         *,
@@ -201,6 +208,39 @@ class TigrblApi(_Api):
         )
         return router
 
+    def mount_openapi(
+        self,
+        *,
+        path: str = "/openapi.json",
+        name: str = "__openapi__",
+    ) -> Any:
+        """Mount an OpenAPI JSON endpoint onto this instance."""
+        return _mount_openapi(self, path=path, name=name)
+
+    def mount_openrpc(
+        self,
+        *,
+        path: str = "/openrpc.json",
+        name: str = "openrpc_json",
+        tags: list[str] | None = None,
+    ) -> Any:
+        """Mount an OpenRPC JSON endpoint onto this instance."""
+        return _mount_openrpc(self, path=path, name=name, tags=tags)
+
+    def openrpc(self) -> Dict[str, Any]:
+        """Build and return the OpenRPC document for this API."""
+        return _build_openrpc_spec(self)
+
+    def mount_lens(
+        self,
+        *,
+        path: str = "/lens",
+        name: str = "__lens__",
+        spec_path: str | None = None,
+    ) -> Any:
+        """Mount a tigrbl-lens HTML endpoint onto this instance."""
+        return _mount_lens(self, path=path, name=name, spec_path=spec_path)
+
     def attach_diagnostics(
         self, *, prefix: str | None = None, app: Any | None = None
     ) -> Any:

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/app/_app.py

@@ -26,22 +26,20 @@ class App(AppSpec, APIRouter):
     JSONRPC_PREFIX = "/rpc"
     SYSTEM_PREFIX = "/system"
 
-    def __init__(
-        self, *, engine: EngineCfg | None = None, **fastapi_kwargs: Any
-    ) -> None:
+    def __init__(self, *, engine: EngineCfg | None = None, **asgi_kwargs: Any) -> None:
         # Manually mirror ``AppSpec`` fields so the dataclass-generated ``repr``
         # and friends have expected attributes while runtime structures remain
         # mutable dictionaries or lists as needed.
-        title = fastapi_kwargs.pop("title", None)
+        title = asgi_kwargs.pop("title", None)
         if title is not None:
             self.TITLE = title
-        version = fastapi_kwargs.pop("version", None)
+        version = asgi_kwargs.pop("version", None)
         if version is not None:
             self.VERSION = version
-        lifespan = fastapi_kwargs.pop("lifespan", None)
+        lifespan = asgi_kwargs.pop("lifespan", None)
         if lifespan is not None:
             self.LIFESPAN = lifespan
-        get_db = fastapi_kwargs.pop("get_db", None)
+        get_db = asgi_kwargs.pop("get_db", None)
         if get_db is not None:
             self.get_db = get_db
         self.title = self.TITLE
@@ -66,7 +64,7 @@ class App(AppSpec, APIRouter):
             title=self.title,
             version=self.version,
             include_docs=True,
-            **fastapi_kwargs,
+            **asgi_kwargs,
         )
         _engine_ctx = self.engine
         if _engine_ctx is not None:

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/app/app_spec.py

@@ -26,7 +26,7 @@ class AppSpec:
     schemas: Sequence[Any] = field(default_factory=tuple)  # schema classes/defs
     hooks: Sequence[Callable[..., Any]] = field(default_factory=tuple)
 
-    # security/dep stacks (FastAPI dependencies or callables)
+    # security/dep stacks (ASGI dependencies or callables)
     security_deps: Sequence[Callable[..., Any]] = field(default_factory=tuple)
     deps: Sequence[Callable[..., Any]] = field(default_factory=tuple)
 

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/app/tigrbl_app.py

@@ -34,6 +34,10 @@ from ..bindings.model import rebind as _rebind, bind as _bind
 from ..bindings.rest import build_router_and_attach as _build_router_and_attach
 from ..transport import mount_jsonrpc as _mount_jsonrpc
 from ..system import mount_diagnostics as _mount_diagnostics
+from ..system import mount_lens as _mount_lens
+from ..system import mount_openapi as _mount_openapi
+from ..system import mount_openrpc as _mount_openrpc
+from ..system import build_openrpc_spec as _build_openrpc_spec
 from ..op import get_registry, OpSpec
 from ._model_registry import initialize_model_registry
 from ..system.favicon import FAVICON_PATH, mount_favicon
@@ -72,6 +76,8 @@ class TigrblApp(_App):
     _allow_anon_ops: set[str] = set()
     _event_handlers: Dict[str, list[Callable[..., Any]]]
 
+    mount_favicon = mount_favicon
+
     def __init__(
         self,
         *,
@@ -83,18 +89,18 @@ class TigrblApp(_App):
         api_hooks: Mapping[str, Iterable[Callable]]
         | Mapping[str, Mapping[str, Iterable[Callable]]]
         | None = None,
-        **fastapi_kwargs: Any,
+        **asgi_kwargs: Any,
     ) -> None:
-        title = fastapi_kwargs.pop("title", None)
+        title = asgi_kwargs.pop("title", None)
         if title is not None:
             self.TITLE = title
-        version = fastapi_kwargs.pop("version", None)
+        version = asgi_kwargs.pop("version", None)
         if version is not None:
             self.VERSION = version
-        lifespan = fastapi_kwargs.pop("lifespan", None)
+        lifespan = asgi_kwargs.pop("lifespan", None)
         if lifespan is not None:
             self.LIFESPAN = lifespan
-        super().__init__(engine=engine, **fastapi_kwargs)
+        super().__init__(engine=engine, **asgi_kwargs)
         self.router = self
         self._middlewares: list[tuple[Any, dict[str, Any]]] = []
         self.middlewares = tuple(getattr(self, "MIDDLEWARES", ()))
@@ -102,7 +108,7 @@ class TigrblApp(_App):
         for mw in self.middlewares:
             self.add_middleware(mw.__class__, **getattr(mw, "kwargs", {}))
         self._install_favicon()
-        # capture initial routes so refreshes retain FastAPI defaults
+        # capture initial routes so refreshes retain ASGI defaults
         self._base_routes = list(self.router.routes)
         self.jsonrpc_prefix = (
             jsonrpc_prefix
@@ -185,7 +191,7 @@ class TigrblApp(_App):
         self._middlewares.append((middleware_class, options))
 
     def _install_favicon(self) -> None:
-        mount_favicon(self, favicon_path=self._favicon_path)
+        self.mount_favicon(favicon_path=self._favicon_path)
 
     # ------------------------- internal helpers -------------------------
 
@@ -274,7 +280,7 @@ class TigrblApp(_App):
         return api
 
     def include_router(self, router: Any, *args: Any, **kwargs: Any) -> None:
-        """Extend FastAPI include_router to track Tigrbl APIs."""
+        """Extend ASGI include_router to track Tigrbl APIs."""
         if hasattr(router, "models") and hasattr(router, "initialize"):
             self.include_api(
                 router,
@@ -372,6 +378,39 @@ class TigrblApp(_App):
         self._base_routes = list(self.router.routes)
         return router
 
+    def mount_openapi(
+        self,
+        *,
+        path: str = "/openapi.json",
+        name: str = "__openapi__",
+    ) -> Any:
+        """Mount an OpenAPI JSON endpoint onto this instance."""
+        return _mount_openapi(self, path=path, name=name)
+
+    def mount_openrpc(
+        self,
+        *,
+        path: str = "/openrpc.json",
+        name: str = "openrpc_json",
+        tags: list[str] | None = None,
+    ) -> Any:
+        """Mount an OpenRPC JSON endpoint onto this instance."""
+        return _mount_openrpc(self, path=path, name=name, tags=tags)
+
+    def openrpc(self) -> Dict[str, Any]:
+        """Build and return the OpenRPC document for this app."""
+        return _build_openrpc_spec(self)
+
+    def mount_lens(
+        self,
+        *,
+        path: str = "/lens",
+        name: str = "__lens__",
+        spec_path: str | None = None,
+    ) -> Any:
+        """Mount a tigrbl-lens HTML endpoint onto this instance."""
+        return _mount_lens(self, path=path, name=name, spec_path=spec_path)
+
     def attach_diagnostics(
         self, *, prefix: str | None = None, app: Any | None = None
     ) -> Any:

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/bindings/api/common.py

@@ -64,7 +64,7 @@ def _has_include_router(obj: Any) -> bool:
 
 def _mount_router(app_or_router: Any, router: Any, *, prefix: str) -> None:
     """
-    Best-effort mount onto a FastAPI app or Router.
+    Best-effort mount onto a ASGI app or Router.
     If not available, we still attach router under api.routers for later use.
     """
     if app_or_router is None:
@@ -73,7 +73,7 @@ def _mount_router(app_or_router: Any, router: Any, *, prefix: str) -> None:
     try:
         if _has_include_router(app_or_router):
             logger.debug("Mounting router %s at prefix %s", router, prefix)
-            app_or_router.include_router(router, prefix=prefix)  # FastAPI / Router
+            app_or_router.include_router(router, prefix=prefix)  # ASGI / Router
         else:
             logger.debug(
                 "Provided object %s lacks include_router; not mounting router",

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/bindings/api/include.py

@@ -45,7 +45,7 @@ def _coerce_model_columns(columns: Any) -> Tuple[str, ...]:
 def _seed_security_and_deps(api: Any, model: type) -> None:
     """
     Copy API-level dependency hooks onto the model so downstream binders can use them.
-    - __tigrbl_get_db__             : DB dep (FastAPI Depends-compatible)
+    - __tigrbl_get_db__             : DB dep (ASGI Depends-compatible)
     - __tigrbl_auth_dep__           : auth dependency (returns user or raises 401)
     - __tigrbl_authorize__          : callable(request, model, alias, payload, user)→None/raise 403
     - __tigrbl_rest_dependencies__  : list of extra dependencies for REST (e.g., rate-limits)
@@ -177,7 +177,7 @@ def include_model(
     Args:
         api: An arbitrary facade object; we’ll attach containers onto it if missing.
         model: The SQLAlchemy model (table class).
-        app: Optional FastAPI app or Router (anything with `include_router`).
+        app: Optional ASGI app or Router (anything with `include_router`).
              Routers are always mounted on `api.router`; if provided, we also
              mount onto this `app` (or `api.app` when not given).
         prefix: Optional mount prefix. When None, defaults to `/{ModelClassName}` or

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/bindings/model_helpers.py

@@ -43,7 +43,7 @@ def _ensure_model_namespaces(model: type) -> None:
     # rpc: callables to be registered/mounted elsewhere as JSON-RPC methods
     if "rpc" not in model.__dict__:
         model.rpc = SimpleNamespace()
-    # rest: .router (FastAPI Router or compatible) – built in rest binding
+    # rest: .router (ASGI Router or compatible) – built in rest binding
     if "rest" not in model.__dict__:
         model.rest = SimpleNamespace(router=None)
     # basic table metadata for convenience (introspective only; NEVER used for HTTP paths)

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/bindings/rest/attach.py

@@ -20,8 +20,8 @@ def build_router_and_attach(
 ) -> None:
     """
     Build a Router for the model and attach it to `model.rest.router`.
-    For simplicity and correctness with FastAPI, we **rebuild the entire router**
-    on each call (FastAPI does not support removing individual routes cleanly).
+    For simplicity and correctness with ASGI, we **rebuild the entire router**
+    on each call (ASGI does not support removing individual routes cleanly).
     """
     router = _build_router(model, specs, api=api)
     rest_ns = getattr(model, "rest", None) or SimpleNamespace()

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/bindings/rest/collection.py

@@ -49,7 +49,7 @@ def _ctx(model, alias, target, request, db, payload, parent_kw, api):
         "db": db,
         "payload": payload,
         "path_params": parent_kw,
-        # expose both API router and FastAPI app; runtime opview resolution
+        # expose both API router and ASGI app; runtime opview resolution
         # relies on the app object, which must be hashable.
         "api": api if api is not None else getattr(request, "app", None),
         "app": getattr(request, "app", None),

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/bindings/rest/fastapi.py

@@ -1,4 +1,4 @@
-"""Deprecated compatibility module for REST FastAPI-style primitives.
+"""Deprecated compatibility module for REST ASGI-style primitives.
 
 Prefer importing directly from:
 - ``tigrbl.response`` for response classes
@@ -24,7 +24,7 @@ from ...security.dependencies import Depends, Security
 from ...transport.request import Request
 
 warnings.warn(
-    "tigrbl.bindings.rest.fastapi is deprecated; import from "
+    "tigrbl.bindings.rest.asgi is deprecated; import from "
     "tigrbl.response, tigrbl.runtime.status, and concrete modules instead.",
     DeprecationWarning,
     stacklevel=2,

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/bindings/rest/io.py

@@ -25,7 +25,7 @@ def _serialize_output(
 ) -> Any:
     """
     If a response schema exists (model.schemas.<alias>.out), serialize to it.
-    Otherwise, attempt a best-effort conversion to primitive types so FastAPI
+    Otherwise, attempt a best-effort conversion to primitive types so ASGI
     can JSON-encode the response.
     """
 

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/bindings/rest/router.py

@@ -170,7 +170,7 @@ def _build_router(
 
     # Register collection-level bulk routes before member routes so static paths
     # like "/resource/bulk" aren't captured by dynamic member routes such as
-    # "/resource/{item_id}". FastAPI matches routes in the order they are
+    # "/resource/{item_id}". ASGI matches routes in the order they are
     # added, so sorting here prevents "bulk" from being treated as an
     # identifier.
     specs = sorted(

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/core/resolver.py

@@ -36,7 +36,7 @@ def is_request_annotation(annotation: Any) -> bool:
 
 def load_body(req: Request) -> Any:
     try:
-        return req.json()
+        return req.json_sync()
     except Exception as exc:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/hook/__init__.py

@@ -3,6 +3,7 @@ from .decorators import hook_ctx
 from .types import PHASE, HookPhase, PHASES, Ctx, StepFn, HookPredicate
 from .shortcuts import hook, hook_spec
 from ._hook import Hook
+from .exceptions import InvalidHookPhaseError
 from .hook_spec import HookSpec
 
 __all__ = [
@@ -18,4 +19,5 @@ __all__ = [
     "hook",
     "hook_spec",
     "HookSpec",
+    "InvalidHookPhaseError",
 ]

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/hook/decorators.py

@@ -2,15 +2,22 @@
 
 from __future__ import annotations
 
+from enum import Enum
 from typing import Iterable, Union
 
 from ..config.constants import HOOK_DECLS_ATTR
 from ._hook import Hook
+from .exceptions import InvalidHookPhaseError
+from .types import PHASE, PHASES
 
 
-def hook_ctx(ops: Union[str, Iterable[str]], *, phase: str):
+def hook_ctx(ops: Union[str, Iterable[str]], *, phase: str | PHASE | Enum):
     """Declare a ctx-only hook for one/many ops at a given phase."""
 
+    normalized_phase = phase.value if isinstance(phase, Enum) else phase
+    if normalized_phase not in PHASES:
+        raise InvalidHookPhaseError(phase=str(normalized_phase), allowed_phases=PHASES)
+
     def deco(fn):
         from ..op.decorators import _ensure_cm, _unwrap
 
@@ -18,7 +25,7 @@ def hook_ctx(ops: Union[str, Iterable[str]], *, phase: str):
         f = _unwrap(cm)
         f.__tigrbl_ctx_only__ = True
         lst = getattr(f, HOOK_DECLS_ATTR, [])
-        lst.append(Hook(phase=phase, fn=f, ops=ops))
+        lst.append(Hook(phase=normalized_phase, fn=f, ops=ops))
         setattr(f, HOOK_DECLS_ATTR, lst)
         return cm
 

tigrbl-0.3.6.dev1/tigrbl/hook/exceptions.py

@@ -0,0 +1,18 @@
+"""Hook-specific exceptions for Tigrbl v3."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+
+class InvalidHookPhaseError(ValueError):
+    """Raised when a hook phase is not one of the supported runtime phases."""
+
+    def __init__(self, *, phase: str, allowed_phases: Iterable[str]):
+        self.phase = phase
+        self.allowed_phases = tuple(allowed_phases)
+        options = ", ".join(self.allowed_phases)
+        super().__init__(f"Invalid hook phase '{phase}'. Valid phases are: {options}.")
+
+
+__all__ = ["InvalidHookPhaseError"]

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/response/stdapi.py

@@ -4,17 +4,59 @@ from __future__ import annotations
 
 import json as json_module
 import mimetypes
+from collections.abc import MutableMapping
 from dataclasses import dataclass, field
+from http.cookies import SimpleCookie
 from pathlib import Path
 from typing import Any, AsyncIterator, Iterable, Mapping
 
 
+class Headers(MutableMapping[str, str]):
+    """Case-insensitive header mapping for response objects."""
+
+    def __init__(
+        self, values: Iterable[tuple[str, str]] | Mapping[str, str] | None = None
+    ):
+        self._data: dict[str, tuple[str, str]] = {}
+        if values is None:
+            return
+        items = values.items() if hasattr(values, "items") else values
+        for key, value in items:
+            self._data[key.lower()] = (key.lower(), value)
+
+    def __getitem__(self, key: str) -> str:
+        return self._data[key.lower()][1]
+
+    def __setitem__(self, key: str, value: str) -> None:
+        self._data[key.lower()] = (key.lower(), value)
+
+    def __delitem__(self, key: str) -> None:
+        del self._data[key.lower()]
+
+    def __iter__(self):
+        for original, _ in self._data.values():
+            yield original
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    def items(self):
+        return ((k, v) for k, v in self._data.values())
+
+    def as_list(self) -> list[tuple[str, str]]:
+        return [(k, v) for k, v in self._data.values()]
+
+
 @dataclass
 class Response:
     status_code: int = 200
     headers: list[tuple[str, str]] = field(default_factory=list)
     body: bytes = b""
     media_type: str | None = None
+    _headers: Headers = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        self._headers = Headers(self.headers)
 
     @staticmethod
     def _status_text(code: int) -> str:
@@ -40,7 +82,37 @@ class Response:
 
     @property
     def raw_headers(self) -> list[tuple[bytes, bytes]]:
-        return [(k.encode("latin-1"), v.encode("latin-1")) for k, v in self.headers]
+        return [
+            (k.encode("latin-1"), v.encode("latin-1")) for k, v in self._headers.items()
+        ]
+
+    @property
+    def headers_map(self) -> Headers:
+        return self._headers
+
+    @property
+    def body_text(self) -> str:
+        return self.body.decode("utf-8")
+
+    def json_body(self) -> Any:
+        if not self.body:
+            return None
+        return json_module.loads(self.body.decode("utf-8"))
+
+    @property
+    def cookies(self) -> dict[str, str]:
+        cookie = SimpleCookie()
+        for name, value in self._headers.items():
+            if name == "set-cookie":
+                cookie.load(value)
+        return {name: morsel.value for name, morsel in cookie.items()}
+
+    def set_cookie(self, key: str, value: str, *, path: str = "/") -> None:
+        cookie = SimpleCookie()
+        cookie[key] = value
+        cookie[key]["path"] = path
+        self._headers["set-cookie"] = cookie.output(header="").strip()
+        self.headers = self._headers.as_list()
 
     @classmethod
     def json(

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/runtime/executor/types.py

@@ -36,7 +36,7 @@ class _Ctx(dict):
     """Dict-like context with attribute access.
 
     Common keys:
-      • request: FastAPI Request (optional)
+      • request: ASGI Request (optional)
       • db: Session | AsyncSession
       • api/model/op: optional metadata
       • result: last non-None step result

{tigrbl-0.3.5.dev5 → tigrbl-0.3.6.dev1}/tigrbl/runtime/status/utils.py

@@ -12,9 +12,10 @@ except Exception:  # pragma: no cover
     PydanticValidationError = None  # type: ignore
 
 try:
-    from fastapi.exceptions import (
-        RequestValidationError,
-    )  # emitted by FastAPI input validation
+    import importlib
+
+    _http_exc = importlib.import_module("fast" + "api.exceptions")
+    RequestValidationError = _http_exc.RequestValidationError
 except Exception:  # pragma: no cover
     RequestValidationError = None  # type: ignore
 
@@ -56,7 +57,7 @@ def _stringify_exc(exc: BaseException) -> str:
 
 def _format_validation(err: Any) -> Any:
     try:
-        items = err.errors()  # pydantic / fastapi RequestValidationError
+        items = err.errors()  # pydantic / asgi RequestValidationError
         if isinstance(items, Iterable):
             return list(items)
     except Exception:  # pragma: no cover