tigrbl 0.3.7.dev1__tar.gz → 0.3.7.dev2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl
-Version: 0.3.7.dev1
+Version: 0.3.7.dev2
 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.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tigrbl"
-version = "0.3.7.dev1"
+version = "0.3.7.dev2"
 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.dev2}/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._request import Request
 from ..transport.rest.decorators import (
     delete as rest_delete,
     get as rest_get,

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev2}/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.dev2}/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._response 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._request import Request
 from .helpers import (
     _Key,
     _coerce_parent_kw,

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

@@ -3,7 +3,7 @@
 Prefer importing directly from:
 - ``tigrbl.response`` for response classes
 - ``tigrbl.runtime.status`` for ``status`` and ``HTTPException``
-- ``tigrbl.api._api`` / ``tigrbl.transport.request`` / ``tigrbl.security.dependencies``
+- ``tigrbl.api._api`` / ``tigrbl.requests._request`` / ``tigrbl.security.dependencies``
 """
 
 from __future__ import annotations
@@ -21,7 +21,7 @@ from ...response import (
 )
 from ...runtime.status import HTTPException, status
 from ...security.dependencies import Depends, Security
-from ...transport.request import Request
+from ...requests._request import Request
 
 warnings.warn(
     "tigrbl.bindings.rest.asgi is deprecated; import from "

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev2}/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._request import Request
 from ...op.types import PHASES
 
 try:

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev2}/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._request import Request
 from .helpers import _ensure_jsonable
 from ...op import OpSpec
 

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev2}/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._request import Request
 from ...op import OpSpec
 from ...security import HTTPBearer
 from ...op.types import CANON

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev2}/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._request import Request
 
 
 def split_annotated(annotation: Any) -> tuple[Any, tuple[Any, ...]]:

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev2}/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._response import Response
 from ..runtime.status.exceptions import HTTPException
 from ..runtime.status.mappings import status
-from ..transport.request import Request
+from ..requests._request import Request
 
 
 def _is_http_response_like(obj: Any) -> bool:

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

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

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

@@ -0,0 +1,69 @@
+"""Shared case-insensitive HTTP header mapping primitives."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping, MutableMapping
+
+
+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()
+
+    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:
+        key = self._attribute_key(name)
+        if key in self._data:
+            return self._data[key][1]
+        raise AttributeError(name)
+
+    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"]

tigrbl-0.3.7.dev2/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.dev2/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.dev2/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.dev2/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.dev2/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.dev2/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.dev2/tigrbl/requests/__init__.py

@@ -0,0 +1,3 @@
+from ._request import Request, AwaitableValue, URL
+
+__all__ = ["Request", "AwaitableValue", "URL"]

tigrbl-0.3.7.dev1/tigrbl/transport/request.py → tigrbl-0.3.7.dev2/tigrbl/requests/_request.py

@@ -3,54 +3,12 @@
 from __future__ import annotations
 
 import json as json_module
-from collections.abc import MutableMapping
-from http.cookies import SimpleCookie
 from dataclasses import dataclass, field
+from http.cookies import SimpleCookie
 from types import SimpleNamespace
 from typing import Any
 
-
-class Headers(MutableMapping[str, str]):
-    """Case-insensitive header mapping."""
-
-    def __init__(self, values: dict[str, str] | None = None) -> None:
-        self._data: dict[str, str] = {}
-        for key, value in (values or {}).items():
-            self._data[key.lower()] = value
-
-    def __getitem__(self, key: str) -> str:
-        return self._data[key.lower()]
-
-    def __setitem__(self, key: str, value: str) -> None:
-        self._data[key.lower()] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self._data[key.lower()]
-
-    def __iter__(self):
-        return iter(self._data)
-
-    def __len__(self) -> int:
-        return len(self._data)
-
-    def get(self, key: str, default: str | None = None) -> str | None:
-        return self._data.get(key.lower(), default)
-
-    @staticmethod
-    def _attribute_key(name: str) -> str:
-        return name.replace("_", "-").lower()
-
-    def __getattr__(self, name: str) -> str:
-        key = self._attribute_key(name)
-        if key in self._data:
-            return self._data[key]
-        raise AttributeError(name)
-
-    def __setattr__(self, name: str, value: str) -> None:
-        if name.startswith("_"):
-            object.__setattr__(self, name, value)
-            return
-        self[self._attribute_key(name)] = value
+from tigrbl.headers import Headers
 
 
 @dataclass(frozen=True)
@@ -89,6 +47,22 @@ class AwaitableValue:
     def __repr__(self) -> str:
         return repr(self.value)
 
+    def __getattr__(self, name: str) -> Any:
+        attr = getattr(self.value, name)
+        if callable(attr):
+
+            def _wrapped(*args: Any, **kwargs: Any) -> Any:
+                return attr(*args, **kwargs)
+
+            return _wrapped
+        return attr
+
+    def __iter__(self):
+        return iter(self.value)
+
+    def __len__(self) -> int:
+        return len(self.value)
+
 
 @dataclass
 class Request:
@@ -142,3 +116,6 @@ class Request:
         parsed = SimpleCookie()
         parsed.load(raw)
         return {name: morsel.value for name, morsel in parsed.items()}
+
+
+__all__ = ["Request", "AwaitableValue", "URL"]

{tigrbl-0.3.7.dev1 → tigrbl-0.3.7.dev2}/tigrbl/response/__init__.py

@@ -1,4 +1,4 @@
-from .stdapi import (
+from ..responses._response import (
     Response as StdApiResponse,
     JSONResponse,
     HTMLResponse,

tigrbl-0.3.7.dev2/tigrbl/response/stdapi.py

@@ -0,0 +1,26 @@
+"""Backward-compatible stdapi response exports.
+
+Prefer importing from ``tigrbl.responses``.
+"""
+
+from tigrbl.headers import Headers
+from tigrbl.responses._response import (
+    FileResponse,
+    HTMLResponse,
+    JSONResponse,
+    PlainTextResponse,
+    RedirectResponse,
+    Response,
+    StreamingResponse,
+)
+
+__all__ = [
+    "Headers",
+    "Response",
+    "JSONResponse",
+    "HTMLResponse",
+    "PlainTextResponse",
+    "StreamingResponse",
+    "FileResponse",
+    "RedirectResponse",
+]

tigrbl-0.3.7.dev2/tigrbl/responses/__init__.py

@@ -0,0 +1,19 @@
+from ._response import (
+    Response,
+    JSONResponse,
+    HTMLResponse,
+    PlainTextResponse,
+    StreamingResponse,
+    FileResponse,
+    RedirectResponse,
+)
+
+__all__ = [
+    "Response",
+    "JSONResponse",
+    "HTMLResponse",
+    "PlainTextResponse",
+    "StreamingResponse",
+    "FileResponse",
+    "RedirectResponse",
+]