tigrbl 0.3.7.dev1__tar.gz → 0.3.7.dev3__tar.gz

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl
-Version: 0.3.7.dev1
+Version: 0.3.7.dev3
 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

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tigrbl"
-version = "0.3.7.dev1"
+version = "0.3.7.dev3"
 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.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/__init__.py

@@ -43,8 +43,8 @@ from .op import alias_ctx, op_ctx, alias, op_alias
 from .hook import hook_ctx
 from .engine.decorators import engine_ctx
 from .schema.decorators import schema_ctx
-from .response.decorators import response_ctx
-from .response.types import ResponseSpec
+from .responses.decorators import response_ctx
+from .responses.types import ResponseSpec
 
 # ── Bindings (model + API orchestration) ───────────────────────────────────────
 from .bindings import (

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/api/_router.py

@@ -37,7 +37,7 @@ from tigrbl.transport.httpx import ensure_httpx_sync_transport
 from ._route import Route
 from ..system.docs.openapi import build_openapi, mount_openapi
 from ..system.docs.swagger import mount_swagger
-from ..transport.request import Request
+from ..requests import Request
 from ..transport.rest.decorators import (
     delete as rest_delete,
     get as rest_get,

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/api/api_spec.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any, Callable, Optional, Sequence
 from ..engine.engine_spec import EngineCfg
-from ..response.types import ResponseSpec
+from ..responses.types import ResponseSpec
 
 
 @dataclass

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/app/app_spec.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass, field
 from typing import Any, Callable, Optional, Sequence
 
 from ..engine.engine_spec import EngineCfg
-from ..response.types import ResponseSpec
+from ..responses.types import ResponseSpec
 
 
 @dataclass(eq=False)

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/app/tigrbl_app.py

@@ -106,7 +106,8 @@ class TigrblApp(_App):
         self.middlewares = tuple(getattr(self, "MIDDLEWARES", ()))
         self._favicon_path = favicon_path
         for mw in self.middlewares:
-            self.add_middleware(mw.__class__, **getattr(mw, "kwargs", {}))
+            mw_cls = getattr(mw, "cls", mw.__class__)
+            self.add_middleware(mw_cls, **getattr(mw, "kwargs", {}))
         self._install_favicon()
         # capture initial routes so refreshes retain ASGI defaults
         self._base_routes = list(self.router.routes)

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/bindings/__init__.py

@@ -46,7 +46,7 @@ from .hooks import normalize_and_attach as build_hooks
 from .handlers import build_and_attach as build_handlers
 from .rpc import register_and_attach as register_rpc
 from .rest import build_router_and_attach as build_rest
-from ..response.bind import bind as bind_response
+from ..responses.bind import bind as bind_response
 
 # API facade integration
 from .api import include_model, include_models, rpc_call

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/bindings/rest/common.py

@@ -13,11 +13,11 @@ from pydantic import BaseModel
 
 from ...api._api import APIRouter as Router
 from ...core.crud.params import Body, Path, Query
-from ...response.stdapi import Response
+from ...responses import Response
 from ...runtime.status.exceptions import HTTPException
 from ...runtime.status.mappings import status as _status
 from ...security.dependencies import Depends, Security
-from ...transport.request import Request
+from ...requests import Request
 from .helpers import (
     _Key,
     _coerce_parent_kw,

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/bindings/rest/fastapi.py

@@ -1,9 +1,9 @@
 """Deprecated compatibility module for REST ASGI-style primitives.
 
 Prefer importing directly from:
-- ``tigrbl.response`` for response classes
+- ``tigrbl.responses`` for response classes
 - ``tigrbl.runtime.status`` for ``status`` and ``HTTPException``
-- ``tigrbl.api._api`` / ``tigrbl.transport.request`` / ``tigrbl.security.dependencies``
+- ``tigrbl.api._api`` / ``tigrbl.requests`` / ``tigrbl.security.dependencies``
 """
 
 from __future__ import annotations
@@ -21,11 +21,11 @@ from ...response import (
 )
 from ...runtime.status import HTTPException, status
 from ...security.dependencies import Depends, Security
-from ...transport.request import Request
+from ...requests import Request
 
 warnings.warn(
     "tigrbl.bindings.rest.asgi is deprecated; import from "
-    "tigrbl.response, tigrbl.runtime.status, and concrete modules instead.",
+    "tigrbl.responses, tigrbl.runtime.status, and concrete modules instead.",
     DeprecationWarning,
     stacklevel=2,
 )

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/bindings/rest/helpers.py

@@ -4,7 +4,7 @@ import logging
 from types import SimpleNamespace
 from typing import Any, Awaitable, Callable, Dict, Mapping, Sequence, Tuple
 
-from ...transport.request import Request
+from ...requests import Request
 from ...op.types import PHASES
 
 try:

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/bindings/rest/io.py

@@ -12,7 +12,7 @@ from pydantic import BaseModel, Field, create_model
 from ...core.crud.params import Query
 from ...runtime.status.exceptions import HTTPException
 from ...runtime.status.mappings import status as _status
-from ...transport.request import Request
+from ...requests import Request
 from .helpers import _ensure_jsonable
 from ...op import OpSpec
 

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/bindings/rest/routing.py

@@ -9,7 +9,7 @@ from typing import Any, Dict, Optional, Sequence, Tuple
 from ...runtime.status.exceptions import HTTPException
 from ...runtime.status.mappings import status as _status
 from ...security.dependencies import Depends, Security
-from ...transport.request import Request
+from ...requests import Request
 from ...op import OpSpec
 from ...security import HTTPBearer
 from ...op.types import CANON

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/core/resolver.py

@@ -7,7 +7,7 @@ from typing import Annotated, Any, Iterable, get_args, get_origin
 from ..core.crud.params import Param
 from ..runtime.status.exceptions import HTTPException
 from ..runtime.status.mappings import status
-from ..transport.request import Request
+from ..requests import Request
 
 
 def split_annotated(annotation: Any) -> tuple[Any, tuple[Any, ...]]:

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/core/router_runtime.py

@@ -10,10 +10,10 @@ from ..api.resolve import (
     resolve_handler_kwargs,
     resolve_route_dependencies,
 )
-from ..response.stdapi import Response
+from ..responses import Response
 from ..runtime.status.exceptions import HTTPException
 from ..runtime.status.mappings import status
-from ..transport.request import Request
+from ..requests import Request
 
 
 def _is_http_response_like(obj: Any) -> bool:

tigrbl-0.3.7.dev3/tigrbl/headers/__init__.py

@@ -0,0 +1,3 @@
+from ._header import HeaderCookies, Headers
+
+__all__ = ["Headers", "HeaderCookies"]

tigrbl-0.3.7.dev3/tigrbl/headers/_header.py

@@ -0,0 +1,89 @@
+"""Shared case-insensitive HTTP header mapping primitives."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping, MutableMapping
+from http.cookies import SimpleCookie
+
+
+class HeaderCookies(dict[str, str]):
+    """Dot-addressable cookie mapping parsed from a Cookie header value."""
+
+    def __getattr__(self, name: str) -> str:
+        try:
+            return self[name]
+        except KeyError as exc:  # pragma: no cover - defensive
+            raise AttributeError(name) from exc
+
+
+class Headers(MutableMapping[str, str]):
+    """Case-insensitive header mapping for request/response objects."""
+
+    def __init__(
+        self,
+        values: Iterable[tuple[str, str]] | Mapping[str, str] | None = 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:
+            lower = key.lower()
+            self._data[lower] = (lower, str(value))
+
+    @staticmethod
+    def _attribute_key(name: str) -> str:
+        return name.replace("_", "-").lower()
+
+    @staticmethod
+    def _parse_cookie_header(value: str) -> HeaderCookies:
+        parsed = SimpleCookie()
+        parsed.load(value)
+        return HeaderCookies({name: morsel.value for name, morsel in parsed.items()})
+
+    def __getitem__(self, key: str) -> str:
+        return self._data[key.lower()][1]
+
+    def __setitem__(self, key: str, value: str) -> None:
+        lower = key.lower()
+        self._data[lower] = (lower, str(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 list(self.items())
+
+    def get(self, key: str, default: str | None = None) -> str | None:
+        item = self._data.get(key.lower())
+        if item is None:
+            return default
+        return item[1]
+
+    def __getattr__(self, name: str) -> str | HeaderCookies:
+        key = self._attribute_key(name)
+        if key not in self._data:
+            raise AttributeError(name)
+        value = self._data[key][1]
+        if key == "cookie":
+            return self._parse_cookie_header(value)
+        return value
+
+    def __setattr__(self, name: str, value: str) -> None:
+        if name.startswith("_"):
+            object.__setattr__(self, name, value)
+            return
+        self[self._attribute_key(name)] = value
+
+
+__all__ = ["Headers", "HeaderCookies"]

tigrbl-0.3.7.dev3/tigrbl/middlewares/__init__.py

@@ -0,0 +1,27 @@
+from .spec import (
+    ASGIApp,
+    ASGIReceive,
+    ASGISend,
+    MiddlewareSpec,
+    WSGIApp,
+    WSGIStartResponse,
+)
+from .middleware import Middleware
+from .decorators import MiddlewareConfig, middleware, middlewares
+from .compose import apply_middlewares
+from .cors import CORSMiddleware
+
+__all__ = [
+    "ASGIApp",
+    "ASGIReceive",
+    "ASGISend",
+    "WSGIApp",
+    "WSGIStartResponse",
+    "MiddlewareSpec",
+    "Middleware",
+    "MiddlewareConfig",
+    "middleware",
+    "middlewares",
+    "apply_middlewares",
+    "CORSMiddleware",
+]

tigrbl-0.3.7.dev3/tigrbl/middlewares/compose.py

@@ -0,0 +1,17 @@
+"""Helpers for composing ASGI/WSGI middleware stacks."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def apply_middlewares(
+    app: Any, middleware_stack: list[tuple[Any, dict[str, Any]]]
+) -> Any:
+    wrapped = app
+    for middleware_class, options in reversed(middleware_stack):
+        wrapped = middleware_class(wrapped, **(options or {}))
+    return wrapped
+
+
+__all__ = ["apply_middlewares"]

tigrbl-0.3.7.dev3/tigrbl/middlewares/cors.py

@@ -0,0 +1,123 @@
+"""CORS middleware for ASGI/WSGI adapters."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from tigrbl.headers import Headers
+
+from .middleware import Middleware
+from .spec import ASGIReceive, ASGISend, WSGIStartResponse
+
+
+class CORSMiddleware(Middleware):
+    def __init__(
+        self,
+        app,
+        *,
+        allow_origin: str = "*",
+        allow_methods: str = "GET,POST,PUT,PATCH,DELETE,OPTIONS",
+        allow_headers: str = "*",
+        allow_credentials: bool = False,
+        max_age: int = 600,
+    ) -> None:
+        super().__init__(
+            app,
+            allow_origin=allow_origin,
+            allow_methods=allow_methods,
+            allow_headers=allow_headers,
+            allow_credentials=allow_credentials,
+            max_age=max_age,
+        )
+        self.allow_origin = allow_origin
+        self.allow_methods = allow_methods
+        self.allow_headers = allow_headers
+        self.allow_credentials = allow_credentials
+        self.max_age = max_age
+
+    def _cors_headers(self) -> list[tuple[str, str]]:
+        headers = [
+            ("access-control-allow-origin", self.allow_origin),
+            ("access-control-allow-methods", self.allow_methods),
+            ("access-control-allow-headers", self.allow_headers),
+            ("access-control-max-age", str(self.max_age)),
+        ]
+        if self.allow_credentials:
+            headers.append(("access-control-allow-credentials", "true"))
+        return headers
+
+    async def asgi(
+        self,
+        scope: dict[str, Any],
+        receive: ASGIReceive,
+        send: ASGISend,
+    ) -> None:
+        if scope.get("type") != "http":
+            await self.app(scope, receive, send)
+            return
+
+        request_headers = Headers(
+            [
+                (k.decode("latin-1"), v.decode("latin-1"))
+                for k, v in scope.get("headers", [])
+            ]
+        )
+        is_preflight = (
+            (scope.get("method") or "").upper() == "OPTIONS"
+            and request_headers.get("origin") is not None
+            and request_headers.get("access-control-request-method") is not None
+        )
+        if is_preflight:
+            await send(
+                {
+                    "type": "http.response.start",
+                    "status": 204,
+                    "headers": [
+                        (k.encode("latin-1"), v.encode("latin-1"))
+                        for k, v in self._cors_headers()
+                    ],
+                }
+            )
+            await send({"type": "http.response.body", "body": b""})
+            return
+
+        async def send_with_cors(message: dict[str, Any]) -> None:
+            if message.get("type") == "http.response.start":
+                headers = list(message.get("headers", []))
+                headers.extend(
+                    [
+                        (k.encode("latin-1"), v.encode("latin-1"))
+                        for k, v in self._cors_headers()
+                    ]
+                )
+                message = {**message, "headers": headers}
+            await send(message)
+
+        await self.app(scope, receive, send_with_cors)
+
+    def wsgi(
+        self,
+        environ: dict[str, Any],
+        start_response: WSGIStartResponse,
+    ) -> list[bytes]:
+        method = (environ.get("REQUEST_METHOD") or "").upper()
+        is_preflight = (
+            method == "OPTIONS"
+            and environ.get("HTTP_ORIGIN")
+            and environ.get("HTTP_ACCESS_CONTROL_REQUEST_METHOD")
+        )
+
+        if is_preflight:
+            start_response("204 No Content", self._cors_headers())
+            return [b""]
+
+        def cors_start_response(
+            status: str, headers: list[tuple[str, str]], *args: Any
+        ):
+            merged = list(headers) + self._cors_headers()
+            return start_response(status, merged, *args)
+
+        return self.app(environ, cors_start_response)
+
+
+__all__ = ["CORSMiddleware"]

tigrbl-0.3.7.dev3/tigrbl/middlewares/decorators.py

@@ -0,0 +1,32 @@
+"""Decorators for attaching middleware specs to apps/apis."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class MiddlewareConfig:
+    cls: Any
+    kwargs: dict[str, Any]
+
+
+def middleware(middleware_class: Any, /, **kwargs: Any) -> MiddlewareConfig:
+    """Build declarative middleware config objects for ``MIDDLEWARES``."""
+
+    return MiddlewareConfig(cls=middleware_class, kwargs=kwargs)
+
+
+def middlewares(*configs: MiddlewareConfig):
+    """Attach middleware configs to class-level ``MIDDLEWARES``."""
+
+    def _decorator(target: Any) -> Any:
+        current = tuple(getattr(target, "MIDDLEWARES", ()))
+        setattr(target, "MIDDLEWARES", current + tuple(configs))
+        return target
+
+    return _decorator
+
+
+__all__ = ["MiddlewareConfig", "middleware", "middlewares"]

tigrbl-0.3.7.dev3/tigrbl/middlewares/middleware.py

@@ -0,0 +1,37 @@
+"""Base middleware implementation supporting ASGI and WSGI."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .spec import ASGIApp, ASGIReceive, ASGISend, WSGIApp, WSGIStartResponse
+
+
+class Middleware:
+    """Base middleware for composing ASGI/WSGI pipelines."""
+
+    def __init__(self, app: ASGIApp | WSGIApp, **kwargs: Any) -> None:
+        self.app = app
+        self.kwargs = kwargs
+
+    async def asgi(
+        self,
+        scope: dict[str, Any],
+        receive: ASGIReceive,
+        send: ASGISend,
+    ) -> None:
+        await self.app(scope, receive, send)
+
+    def wsgi(
+        self,
+        environ: dict[str, Any],
+        start_response: WSGIStartResponse,
+    ) -> list[bytes]:
+        return self.app(environ, start_response)
+
+    def __call__(self, *args: Any, **kwargs: Any):
+        if len(args) == 3 and isinstance(args[0], dict):
+            return self.asgi(args[0], args[1], args[2])
+        if len(args) == 2 and isinstance(args[0], dict):
+            return self.wsgi(args[0], args[1])
+        raise TypeError("Invalid middleware invocation")

tigrbl-0.3.7.dev3/tigrbl/middlewares/spec.py

@@ -0,0 +1,26 @@
+"""Middleware protocol and callable type specs."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Any, Protocol
+
+ASGIReceive = Callable[[], Awaitable[dict[str, Any]]]
+ASGISend = Callable[[dict[str, Any]], Awaitable[None]]
+ASGIApp = Callable[[dict[str, Any], ASGIReceive, ASGISend], Awaitable[None]]
+WSGIStartResponse = Callable[..., Any]
+WSGIApp = Callable[[dict[str, Any], WSGIStartResponse], list[bytes]]
+
+
+class MiddlewareSpec(Protocol):
+    """Protocol for middleware classes compatible with ASGI and WSGI."""
+
+    kwargs: dict[str, Any]
+
+    async def asgi(
+        self, scope: dict[str, Any], receive: ASGIReceive, send: ASGISend
+    ) -> None: ...
+
+    def wsgi(
+        self, environ: dict[str, Any], start_response: WSGIStartResponse
+    ) -> list[bytes]: ...

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev3}/tigrbl/op/types.py

@@ -8,7 +8,7 @@ from typing import Any, Literal, Mapping, Optional, Tuple, cast
 from ..config.constants import CANON as CANONICAL_VERB_TUPLE
 from ..hook.types import PHASE, HookPhase, PHASES, Ctx, StepFn, HookPredicate
 from ..hook import HookSpec as OpHook
-from ..response.types import ResponseSpec
+from ..responses.types import ResponseSpec
 from ..engine.engine_spec import EngineCfg
 from typing import TYPE_CHECKING
 

tigrbl-0.3.7.dev3/tigrbl/requests/__init__.py

@@ -0,0 +1,5 @@
+from tigrbl.headers import Headers
+
+from ._request import AwaitableValue, Request, URL
+
+__all__ = ["Headers", "Request", "AwaitableValue", "URL"]