tigrbl 0.3.9.dev1__tar.gz → 0.3.10.dev1__tar.gz

{tigrbl-0.3.9.dev1 → tigrbl-0.3.10.dev1}/PKG-INFO

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

{tigrbl-0.3.9.dev1 → tigrbl-0.3.10.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tigrbl"
-version = "0.3.9.dev1"
+version = "0.3.10.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.9.dev1 → tigrbl-0.3.10.dev1}/tigrbl/api/_api.py

@@ -18,6 +18,9 @@ class Api(APISpec, Router):
 
     MODELS: tuple[Any, ...] = ()
     TABLES: tuple[Any, ...] = ()
+    REST_PREFIX = "/api"
+    RPC_PREFIX = "/rpc"
+    SYSTEM_PREFIX = "/system"
 
     # dataclass inheritance makes instances unhashable; use identity semantics
     # for both hashing and equality so objects can participate in sets/dicts
@@ -48,6 +51,9 @@ class Api(APISpec, Router):
         self.security_deps = tuple(getattr(self, "SECURITY_DEPS", ()))
         self.deps = tuple(getattr(self, "DEPS", ()))
         self.response = getattr(self, "RESPONSE", None)
+        self.rest_prefix = getattr(self, "REST_PREFIX", "/api")
+        self.rpc_prefix = getattr(self, "RPC_PREFIX", "/rpc")
+        self.system_prefix = getattr(self, "SYSTEM_PREFIX", "/system")
         # ``models`` is expected to be a dict at runtime for registry lookups.
         self.models = initialize_model_registry(getattr(self, "MODELS", ()))
 

{tigrbl-0.3.9.dev1 → tigrbl-0.3.10.dev1}/tigrbl/api/_router.py

@@ -25,13 +25,15 @@ from tigrbl.core.router_runtime import (
     dispatch,
     is_metadata_route,
 )
-from tigrbl.transport.asgi_wsgi import (
+from tigrbl.app.transport import (
     asgi_app as _asgi_app_impl,
-    request_from_asgi as _request_from_asgi_impl,
-    request_from_wsgi as _request_from_wsgi_impl,
     router_call as _router_call_impl,
     wsgi_app as _wsgi_app_impl,
 )
+from tigrbl.requests.adapters import (
+    request_from_asgi as _request_from_asgi_impl,
+    request_from_wsgi as _request_from_wsgi_impl,
+)
 from tigrbl.transport.httpx import ensure_httpx_sync_transport
 
 from ._route import Route

{tigrbl-0.3.9.dev1 → tigrbl-0.3.10.dev1}/tigrbl/api/tigrbl_api.py

@@ -52,6 +52,9 @@ class TigrblApi(_Api):
     """
 
     PREFIX = ""
+    REST_PREFIX = "/api"
+    RPC_PREFIX = "/rpc"
+    SYSTEM_PREFIX = "/system"
     TAGS: Sequence[Any] = ()
     APIS: Sequence[Any] = ()
     MODELS: Sequence[Any] = ()
@@ -84,13 +87,14 @@ class TigrblApi(_Api):
         self.jsonrpc_prefix = (
             jsonrpc_prefix
             if jsonrpc_prefix is not None
-            else getattr(self, "JSONRPC_PREFIX", "/rpc")
+            else getattr(self, "RPC_PREFIX", getattr(self, "JSONRPC_PREFIX", "/rpc"))
         )
         self.system_prefix = (
             system_prefix
             if system_prefix is not None
             else getattr(self, "SYSTEM_PREFIX", "/system")
         )
+        self.rest_prefix = getattr(self, "REST_PREFIX", "/api")
 
         # public containers (mirrors used by bindings.api)
         self.models = initialize_model_registry(getattr(self, "MODELS", ()))
@@ -106,6 +110,9 @@ class TigrblApi(_Api):
         self.core = SimpleNamespace()
         self.core_raw = SimpleNamespace()
 
+        # Auto-mount canonical API surfaces for standalone usage.
+        self.mount_jsonrpc()
+
         # API-level hooks map (merged into each model at include-time; precedence handled in bindings.hooks)
         self._api_hooks_map = copy.deepcopy(api_hooks) if api_hooks else None
         if models:
@@ -158,9 +165,12 @@ class TigrblApi(_Api):
         """
         # inject API-level hooks so the binder merges them
         self._merge_api_hooks_into_model(model, self._api_hooks_map)
-        return _include_model(
+        included_model, router = _include_model(
             self, model, app=None, prefix=prefix, mount_router=mount_router
         )
+        if mount_router and prefix is None and router is not None:
+            self.include_router(router, prefix=self.rest_prefix)
+        return included_model, router
 
     def include_models(
         self,
@@ -171,13 +181,18 @@ class TigrblApi(_Api):
     ) -> Dict[str, Any]:
         for m in models:
             self._merge_api_hooks_into_model(m, self._api_hooks_map)
-        return _include_models(
+        included = _include_models(
             self,
             models,
             app=None,
             base_prefix=base_prefix,
             mount_router=mount_router,
         )
+        if mount_router and base_prefix is None:
+            for router in included.values():
+                if router is not None:
+                    self.include_router(router, prefix=self.rest_prefix)
+        return included
 
     async def rpc_call(
         self,

{tigrbl-0.3.9.dev1 → tigrbl-0.3.10.dev1}/tigrbl/app/tigrbl_app.py

@@ -18,12 +18,11 @@ from typing import (
 )
 
 from ._app import App as _App
+from ..api.tigrbl_api import TigrblApi
 from ..engine.engine_spec import EngineCfg
 from ..engine import resolver as _resolver
 from ..ddl import initialize as _ddl_initialize
 from ..bindings.api import (
-    include_model as _include_model,
-    include_models as _include_models,
     rpc_call as _rpc_call,
     _seed_security_and_deps,
     _mount_router,
@@ -127,6 +126,7 @@ class TigrblApp(_App):
         self.schemas = SimpleNamespace()
         self.handlers = SimpleNamespace()
         self.hooks = tuple(getattr(self, "HOOKS", ()))
+        self.state = SimpleNamespace()
         self.rpc = SimpleNamespace()
         self.rest = SimpleNamespace()
         self.routers: Dict[str, Any] = {}
@@ -143,6 +143,9 @@ class TigrblApp(_App):
 
         # API-level hooks map (merged into each model at include-time; precedence handled in bindings.hooks)
         self._api_hooks_map = copy.deepcopy(api_hooks) if api_hooks else None
+        self._default_api: TigrblApi | None = None
+        self.mount_openrpc(path="/openrpc.json")
+        self.mount_lens(path="/rdocs", spec_path="/openrpc.json")
         if apis:
             self.apis.extend(list(apis))
             self.include_apis(self.apis)
@@ -233,17 +236,47 @@ class TigrblApp(_App):
 
     # ------------------------- primary operations -------------------------
 
+    def _ensure_default_api(self) -> TigrblApi:
+        """Create and register the app-scoped default API when needed."""
+        if self._default_api is None:
+            self._default_api = TigrblApi(
+                engine=self.engine,
+                api_hooks=self._api_hooks_map,
+            )
+            # Mirror current app auth knobs onto the default API.
+            self._default_api.set_auth(
+                authn=self._authn,
+                allow_anon=self._allow_anon,
+                authorize=self._authorize,
+                optional_authn_dep=self._optional_authn_dep,
+            )
+            self.include_api(self._default_api)
+        return self._default_api
+
     def include_model(
         self, model: type, *, prefix: str | None = None, mount_router: bool = True
     ) -> Tuple[type, Any]:
         """
-        Bind a model, mount its REST router, and attach all namespaces to this facade.
+        Include a model through an internal ``TigrblApi`` mounted on this app.
         """
-        if not isinstance(self.hooks, SimpleNamespace):
-            self.hooks = SimpleNamespace()
-        # inject API-level hooks so the binder merges them
-        self._merge_api_hooks_into_model(model, self._api_hooks_map)
-        return _include_model(self, model, prefix=prefix, mount_router=mount_router)
+        default_api = self._ensure_default_api()
+
+        result = default_api.include_model(
+            model,
+            prefix=prefix,
+            mount_router=mount_router,
+        )
+        if mount_router:
+            _, router = result
+            if router is not None:
+                mount_prefix = prefix if prefix is not None else _default_prefix(model)
+                self.include_router(router, prefix=mount_prefix)
+                self.include_router(
+                    router,
+                    prefix=f"{default_api.rest_prefix}{mount_prefix}",
+                )
+        self._sync_default_api_namespaces()
+        return result
 
     def include_models(
         self,
@@ -252,16 +285,51 @@ class TigrblApp(_App):
         base_prefix: str | None = None,
         mount_router: bool = True,
     ) -> Dict[str, Any]:
-        if not isinstance(self.hooks, SimpleNamespace):
-            self.hooks = SimpleNamespace()
-        for m in models:
-            self._merge_api_hooks_into_model(m, self._api_hooks_map)
-        return _include_models(
-            self,
+        default_api = self._ensure_default_api()
+
+        result = default_api.include_models(
             models,
             base_prefix=base_prefix,
             mount_router=mount_router,
         )
+        if mount_router:
+            for model in models:
+                router = getattr(
+                    getattr(model, "rest", SimpleNamespace()),
+                    "router",
+                    None,
+                )
+                if router is None:
+                    continue
+                mount_prefix = (
+                    f"{base_prefix}{_default_prefix(model)}"
+                    if base_prefix is not None
+                    else _default_prefix(model)
+                )
+                self.include_router(router, prefix=mount_prefix)
+                self.include_router(
+                    router,
+                    prefix=f"{default_api.rest_prefix}{mount_prefix}",
+                )
+        self._sync_default_api_namespaces()
+        return result
+
+    def _sync_default_api_namespaces(self) -> None:
+        """Mirror the auto-created API registries onto the app facade."""
+        if self._default_api is None:
+            return
+        self.models = self._default_api.models
+        self.schemas = self._default_api.schemas
+        self.handlers = self._default_api.handlers
+        self.hooks = self._default_api.hooks
+        self.rpc = self._default_api.rpc
+        self.rest = self._default_api.rest
+        self.routers = self._default_api.routers
+        self.tables = self._default_api.tables
+        self.columns = self._default_api.columns
+        self.table_config = self._default_api.table_config
+        self.core = self._default_api.core
+        self.core_raw = self._default_api.core_raw
 
     def include_api(
         self,
@@ -479,6 +547,15 @@ class TigrblApp(_App):
         if optional_authn_dep is not None:
             self._optional_authn_dep = optional_authn_dep
 
+        if self._default_api is not None:
+            self._default_api.set_auth(
+                authn=self._authn,
+                allow_anon=self._allow_anon,
+                authorize=self._authorize,
+                optional_authn_dep=self._optional_authn_dep,
+            )
+            self._sync_default_api_namespaces()
+
         # Refresh already-included models so routers pick up new auth settings
         if self.models:
             self._refresh_security()

tigrbl-0.3.9.dev1/tigrbl/transport/asgi_wsgi.py → tigrbl-0.3.10.dev1/tigrbl/app/transport.py

@@ -1,39 +1,15 @@
-"""ASGI and WSGI runtime adapters for stdapi routers."""
+"""ASGI/WSGI application adapters for router instances."""
 
 from __future__ import annotations
 
 import asyncio
 import traceback
 from typing import Any, Callable
-from urllib.parse import parse_qs
 
 from tigrbl.middlewares import apply_middlewares
-from tigrbl.requests import Request
+from tigrbl.requests.adapters import request_from_asgi, request_from_wsgi
 from tigrbl.responses import Response
-
-
-NO_BODY_STATUS = set(range(100, 200)) | {204, 205, 304}
-
-
-def _finalize_response(
-    scope: dict[str, Any],
-    status: int,
-    headers: list[tuple[bytes, bytes]],
-    body: bytes,
-) -> tuple[list[tuple[bytes, bytes]], bytes]:
-    """Enforce HTTP body/header invariants immediately before transport writes."""
-
-    method = str(scope.get("method", "GET")).upper()
-
-    if method == "HEAD" or status in NO_BODY_STATUS:
-        drop = {b"content-length", b"content-type", b"transfer-encoding"}
-        headers = [(k, v) for (k, v) in headers if k.lower() not in drop]
-        return headers, b""
-
-    headers = [(k, v) for (k, v) in headers if k.lower() != b"content-length"]
-    headers.append((b"content-length", str(len(body)).encode("latin-1")))
-
-    return headers, body
+from tigrbl.responses._transport import finalize_transport_response
 
 
 async def asgi_app(
@@ -107,7 +83,7 @@ async def asgi_app(
 
         req = request_from_asgi(router, scope, body)
         resp = await router._dispatch(req)
-        headers, finalized_body = _finalize_response(
+        headers, finalized_body = finalize_transport_response(
             scope,
             resp.status_code,
             [(k.encode("latin-1"), v.encode("latin-1")) for k, v in resp.headers],
@@ -142,7 +118,7 @@ def wsgi_app(
     ) -> list[bytes]:
         req = request_from_wsgi(router, _environ)
         resp = asyncio.run(router._dispatch(req))
-        headers, finalized_body = _finalize_response(
+        headers, finalized_body = finalize_transport_response(
             {"method": req.method},
             resp.status_code,
             [(k.encode("latin-1"), v.encode("latin-1")) for k, v in resp.headers],
@@ -169,63 +145,6 @@ def wsgi_app(
     return [resp.body]
 
 
-def request_from_wsgi(router: Any, environ: dict[str, Any]) -> Request:
-    method = (environ.get("REQUEST_METHOD") or "GET").upper()
-    path = environ.get("PATH_INFO") or "/"
-    script_name = environ.get("SCRIPT_NAME") or ""
-
-    headers: dict[str, str] = {}
-    for key, value in environ.items():
-        if key.startswith("HTTP_"):
-            header_key = key[5:].replace("_", "-").lower()
-            headers[header_key] = str(value)
-    if "CONTENT_TYPE" in environ:
-        headers["content-type"] = str(environ["CONTENT_TYPE"])
-
-    query = parse_qs(environ.get("QUERY_STRING") or "", keep_blank_values=True)
-
-    try:
-        length = int(environ.get("CONTENT_LENGTH") or "0")
-    except ValueError:
-        length = 0
-    body = environ["wsgi.input"].read(length) if length > 0 else b""
-
-    return Request(
-        method=method,
-        path=path,
-        headers=headers,
-        query=query,
-        path_params={},
-        body=body,
-        script_name=script_name,
-        app=router,
-    )
-
-
-def request_from_asgi(router: Any, scope: dict[str, Any], body: bytes) -> Request:
-    method = (scope.get("method") or "GET").upper()
-    path = scope.get("path") or "/"
-    headers: dict[str, str] = {
-        key.decode("latin-1").lower(): value.decode("latin-1")
-        for key, value in scope.get("headers", [])
-    }
-    query = parse_qs(
-        scope.get("query_string", b"").decode("latin-1"),
-        keep_blank_values=True,
-    )
-    return Request(
-        method=method,
-        path=path,
-        headers=headers,
-        query=query,
-        path_params={},
-        body=body,
-        script_name=scope.get("root_path") or "",
-        app=router,
-        scope=scope,
-    )
-
-
 def router_call(router: Any, *args: Any, **kwargs: Any):
     del kwargs
     if len(args) == 2 and isinstance(args[0], dict) and callable(args[1]):
@@ -240,3 +159,6 @@ def router_call(router: Any, *args: Any, **kwargs: Any):
     if len(args) == 3 and isinstance(args[0], dict):
         return asgi_app(router, args[0], args[1], args[2])
     raise TypeError("Invalid ASGI/WSGI invocation")
+
+
+__all__ = ["asgi_app", "router_call", "wsgi_app"]

{tigrbl-0.3.9.dev1 → tigrbl-0.3.10.dev1}/tigrbl/middlewares/__init__.py

@@ -7,6 +7,7 @@ from .spec import (
     WSGIStartResponse,
 )
 from .middleware import Middleware
+from .base import BaseHTTPMiddleware
 from .decorators import MiddlewareConfig, middleware, middlewares
 from .compose import apply_middlewares
 from .cors import CORSMiddleware
@@ -19,6 +20,7 @@ __all__ = [
     "WSGIStartResponse",
     "MiddlewareSpec",
     "Middleware",
+    "BaseHTTPMiddleware",
     "MiddlewareConfig",
     "middleware",
     "middlewares",

tigrbl-0.3.10.dev1/tigrbl/middlewares/base.py

@@ -0,0 +1,142 @@
+"""Request/response middleware base with ``dispatch`` + ``call_next`` semantics."""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import urlencode
+
+from tigrbl.requests import Request
+from tigrbl.requests.adapters import request_from_asgi
+from tigrbl.responses import Response
+from tigrbl.responses._transport import finalize_transport_response
+
+from .middleware import Middleware
+from .spec import ASGIReceive, ASGISend
+
+
+class BaseHTTPMiddleware(Middleware):
+    """Base middleware for intercepting HTTP requests in ASGI mode."""
+
+    async def dispatch(
+        self,
+        request: Request,
+        call_next: Any,
+    ) -> Response:
+        """Process the request and optionally delegate to downstream middleware/app."""
+
+        return await call_next(request)
+
+    @staticmethod
+    def _scope_from_request(scope: dict[str, Any], request: Request) -> dict[str, Any]:
+        query_string = urlencode(
+            [
+                (name, value)
+                for name, values in request.query.items()
+                for value in values
+            ],
+            doseq=True,
+        ).encode("latin-1")
+        return {
+            **scope,
+            "method": request.method,
+            "path": request.path,
+            "query_string": query_string,
+            "headers": [
+                (key.encode("latin-1"), value.encode("latin-1"))
+                for key, value in request.headers.items()
+            ],
+            "root_path": request.script_name,
+        }
+
+    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_body = b""
+        more_body = True
+        while more_body:
+            message = await receive()
+            request_body += message.get("body", b"")
+            more_body = message.get("more_body", False)
+
+        request = request_from_asgi(None, scope, request_body)
+
+        async def call_next(forward_request: Request | None = None) -> Response:
+            target_request = forward_request or request
+            target_scope = self._scope_from_request(scope, target_request)
+
+            messages: list[dict[str, Any]] = []
+            body_sent = False
+
+            async def receive_for_app() -> dict[str, Any]:
+                nonlocal body_sent
+                if body_sent:
+                    return {"type": "http.request", "body": b"", "more_body": False}
+                body_sent = True
+                return {
+                    "type": "http.request",
+                    "body": target_request.body,
+                    "more_body": False,
+                }
+
+            async def send_from_app(message: dict[str, Any]) -> None:
+                messages.append(message)
+
+            await self.app(target_scope, receive_for_app, send_from_app)
+
+            start = next(
+                message
+                for message in messages
+                if message.get("type") == "http.response.start"
+            )
+            raw_headers = list(start.get("headers", []))
+            body = b"".join(
+                message.get("body", b"")
+                for message in messages
+                if message.get("type") == "http.response.body"
+            )
+            headers, finalized_body = finalize_transport_response(
+                target_scope,
+                int(start.get("status", 200)),
+                raw_headers,
+                body,
+            )
+            return Response(
+                status_code=int(start.get("status", 200)),
+                headers=[
+                    (key.decode("latin-1"), value.decode("latin-1"))
+                    for key, value in headers
+                ],
+                body=finalized_body,
+            )
+
+        response = await self.dispatch(request, call_next)
+        headers, finalized_body = finalize_transport_response(
+            scope,
+            response.status_code,
+            response.raw_headers,
+            response.body,
+        )
+        await send(
+            {
+                "type": "http.response.start",
+                "status": response.status_code,
+                "headers": headers,
+            }
+        )
+        await send(
+            {
+                "type": "http.response.body",
+                "body": finalized_body,
+                "more_body": False,
+            }
+        )
+
+
+__all__ = ["BaseHTTPMiddleware"]