tigrbl 0.3.17.dev11__tar.gz → 0.3.17.dev12__tar.gz

{tigrbl-0.3.17.dev11 → tigrbl-0.3.17.dev12}/PKG-INFO

@@ -1,10 +1,9 @@
 Metadata-Version: 2.4
 Name: tigrbl
-Version: 0.3.17.dev11
+Version: 0.3.17.dev12
 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
-Keywords: tigrbl,sdk,standards,asgi,rest,rpc
 Author: Jacob Stewart
 Author-email: jacob@swarmauri.com
 Requires-Python: >=3.10,<3.13
@@ -27,6 +26,10 @@ Requires-Dist: jinja2 (>=3.1.4) ; extra == "templates"
 Requires-Dist: psycopg2-binary (>=2.9.9) ; extra == "postgres"
 Requires-Dist: pydantic (>=2.0.0)
 Requires-Dist: sqlalchemy (>=2.0)
+Requires-Dist: tigrbl-canon
+Requires-Dist: tigrbl-concrete
+Requires-Dist: tigrbl-orm
+Requires-Dist: tigrbl-runtime
 Requires-Dist: tigrbl-tests ; extra == "tests"
 Requires-Dist: uvicorn
 Description-Content-Type: text/markdown

{tigrbl-0.3.17.dev11 → tigrbl-0.3.17.dev12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tigrbl"
-version = "0.3.17.dev11"
+version = "0.3.17.dev12"
 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"
@@ -18,22 +18,19 @@ classifiers = [
 ]
 authors = [{ name = "Jacob Stewart", email = "jacob@swarmauri.com" }]
 dependencies = [
+    "tigrbl-concrete",
+    "tigrbl-canon",
+    "tigrbl-runtime",
+    "tigrbl-orm",
     "pydantic>=2.0.0",
     "sqlalchemy>=2.0",
     "aiosqlite>=0.19.0",
     "httpx>=0.27.0",
     "greenlet>=3.2.3",
-    "uvicorn", 
-]
-keywords = [
-    'tigrbl',
-    'sdk',
-    'standards',
-    'asgi',
-    'rest',
-    'rpc',
+    "uvicorn",
 ]
 
+
 [project.optional-dependencies]
 postgres = [
     "asyncpg>=0.30.0",
@@ -47,9 +44,14 @@ tests = [
 ]
 
 [tool.uv.sources]
+"tigrbl-concrete" = { workspace = true }
+"tigrbl-canon" = { workspace = true }
+"tigrbl-runtime" = { workspace = true }
+"tigrbl-orm" = { workspace = true }
 tigrbl-tests = { workspace = true }
 tigrbl_client = { workspace = true }
 
+
 [tool.pytest.ini_options]
 norecursedirs = ["combined", "scripts"]
 testpaths = ["../tigrbl_tests/tests"]

{tigrbl-0.3.17.dev11 → tigrbl-0.3.17.dev12}/tigrbl/__init__.py

@@ -9,6 +9,10 @@ register RPC & REST, and (optionally) mount JSON-RPC and diagnostics.
 
 from __future__ import annotations
 
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)
+
 from ._concrete import Router
 
 # ── OpSpec (source of truth) ───────────────────────────────────────────────────

tigrbl-0.3.17.dev11/tigrbl/_base/__init__.py

@@ -1,24 +0,0 @@
-"""Base class implementations for tigrbl internals."""
-
-from ._hook_base import HookBase
-from ._storage import ForeignKeyBase
-from ._op_base import OpBase
-from ._request_base import RequestBase
-from ._schema_base import SchemaBase
-from ._session_abc import SessionABC
-from ._session_base import TigrblSessionBase
-from ._table_base import TableBase
-from ._table_registry_base import TableRegistryBase
-
-
-__all__ = [
-    "HookBase",
-    "ForeignKeyBase",
-    "OpBase",
-    "RequestBase",
-    "SchemaBase",
-    "SessionABC",
-    "TigrblSessionBase",
-    "TableBase",
-    "TableRegistryBase",
-]

tigrbl-0.3.17.dev11/tigrbl/_base/_hook_base.py

@@ -1,25 +0,0 @@
-"""Base runtime hook wrapper for Tigrbl v3."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Iterable, Optional, Union
-
-from ..hook.types import HookPhase, StepFn
-from .._spec.hook_spec import HookSpec
-
-
-@dataclass(frozen=True, slots=True)
-class HookBase(HookSpec):
-    """Base hook bound to a phase and one or more ops."""
-
-    phase: HookPhase
-    fn: StepFn
-    ops: Union[str, Iterable[str]] = "*"
-    order: int = 0
-    when: Optional[object] = None
-    name: Optional[str] = None
-    description: Optional[str] = None
-
-
-__all__ = ["HookBase"]

tigrbl-0.3.17.dev11/tigrbl/_base/_middleware_base.py

@@ -1,141 +0,0 @@
-"""Request/response middleware base with ``dispatch`` + ``call_next`` semantics."""
-
-from __future__ import annotations
-
-from typing import Any
-from urllib.parse import urlencode
-
-from tigrbl._concrete._request import Request
-from tigrbl._concrete._request_adapters import request_from_asgi
-from tigrbl._concrete._response import Response
-from tigrbl.runtime.atoms.egress.asgi_send import finalize_transport_response
-
-from .._spec.middleware_spec import MiddlewareSpec, ASGIReceive, ASGISend, Message
-
-
-class MiddlewareBase(MiddlewareSpec):
-    """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[Message] = []
-            body_sent = False
-
-            async def receive_for_app() -> Message:
-                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: Message) -> 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__ = ["MiddlewareBase"]

tigrbl-0.3.17.dev11/tigrbl/_base/_op_base.py

@@ -1,12 +0,0 @@
-"""Base operation descriptor implementation for Tigrbl."""
-
-from __future__ import annotations
-
-from .._spec.op_spec import OpSpec
-
-
-class OpBase(OpSpec):
-    """Base operation descriptor type."""
-
-
-__all__ = ["OpBase"]

tigrbl-0.3.17.dev11/tigrbl/_base/_request_base.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .._spec.request_spec import RequestSpec
-
-
-class RequestBase(RequestSpec):
-    """Base request model behavior shared by concrete request implementations."""
-
-    @classmethod
-    def from_scope(
-        cls,
-        scope: dict[str, Any],
-        receive: Any | None = None,
-        *,
-        app: Any | None = None,
-        state: Any | None = None,
-    ) -> "RequestBase":
-        """Construct a request from an ASGI scope.
-
-        Middleware/tests may resolve ``Request`` through base/spec surfaces during
-        import cycles. Delegate to the concrete request model to keep
-        ``Request.from_scope(...)`` consistently available.
-        """
-
-        from tigrbl._concrete._request import Request
-
-        return Request.from_scope(scope, receive, app=app, state=state)
-
-
-__all__ = ["RequestBase"]

tigrbl-0.3.17.dev11/tigrbl/_base/_response_base.py

@@ -1,231 +0,0 @@
-from __future__ import annotations
-
-import json as json_module
-from dataclasses import dataclass
-from http.cookies import SimpleCookie
-from typing import Any, Mapping
-
-from tigrbl._concrete._headers import HeaderCookies, Headers
-
-from .._spec.response_spec import ResponseSpec, TemplateSpec
-
-
-class _JSONDualMethod:
-    def __get__(
-        self,
-        obj: "ResponseBase" | None,
-        owner: type["ResponseBase"],
-    ):
-        if obj is None:
-
-            def _factory(
-                data: Any,
-                status_code: int = 200,
-                headers: Mapping[str, str] | None = None,
-            ) -> "ResponseBase":
-                return owner.from_json(data, status_code=status_code, headers=headers)
-
-            return _factory
-
-        def _instance_json() -> Any:
-            return obj.json_body()
-
-        return _instance_json
-
-
-class ResponseBase(ResponseSpec):
-    """Concrete HTTP response object that also implements ``ResponseSpec``."""
-
-    json = _JSONDualMethod()
-
-    def __init__(
-        self,
-        *,
-        status_code: int = 200,
-        headers: Mapping[str, str] | list[tuple[str, str]] | None = None,
-        body: bytes | None = None,
-        content: bytes | None = None,
-        media_type: str | None = None,
-        kind: str = "auto",
-        envelope: bool | None = None,
-        template: TemplateSpec | None = None,
-        filename: str | None = None,
-        download: bool | None = None,
-        etag: str | None = None,
-        cache_control: str | None = None,
-        redirect_to: str | None = None,
-    ) -> None:
-        if body is not None and content is not None:
-            raise TypeError(
-                "ResponseBase: provide either 'body' or 'content', not both"
-            )
-
-        payload = (
-            body if body is not None else (content if content is not None else b"")
-        )
-
-        super().__init__(
-            kind=kind,
-            media_type=media_type,
-            status_code=status_code,
-            headers={
-                k: v
-                for k, v in (
-                    headers.items() if hasattr(headers, "items") else (headers or [])
-                )
-            },
-            envelope=envelope,
-            template=template,
-            filename=filename,
-            download=download,
-            etag=etag,
-            cache_control=cache_control,
-            redirect_to=redirect_to,
-        )
-        self.status_code = status_code
-        self.headers = Headers(headers or {})
-        self.body = payload
-        self.media_type = media_type
-        self._headers = self.headers
-
-    @staticmethod
-    def _status_text(code: int) -> str:
-        return {
-            200: "OK",
-            201: "Created",
-            205: "Reset Content",
-            204: "No Content",
-            301: "Moved Permanently",
-            302: "Found",
-            307: "Temporary Redirect",
-            308: "Permanent Redirect",
-            400: "Bad Request",
-            401: "Unauthorized",
-            403: "Forbidden",
-            404: "Not Found",
-            405: "Method Not Allowed",
-            422: "Unprocessable Entity",
-            500: "Internal Server Error",
-        }.get(code, "OK")
-
-    def status_line(self) -> str:
-        return f"{self.status_code} {self._status_text(self.status_code)}"
-
-    @property
-    def raw_headers(self) -> list[tuple[bytes, bytes]]:
-        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) -> HeaderCookies:
-        cookie = SimpleCookie()
-        for name, value in self.headers.items():
-            if name == "set-cookie":
-                cookie.load(value)
-        return HeaderCookies({name: morsel.value for name, morsel in cookie.items()})
-
-    def set_cookie(
-        self,
-        key: str,
-        value: str,
-        *,
-        path: str = "/",
-        domain: str | None = None,
-        secure: bool = False,
-        httponly: bool = False,
-        samesite: str | None = None,
-        max_age: int | None = None,
-        expires: str | None = None,
-    ) -> None:
-        cookie = SimpleCookie()
-        cookie[key] = value
-        morsel = cookie[key]
-        morsel["path"] = path
-        if domain is not None:
-            morsel["domain"] = domain
-        if secure:
-            morsel["secure"] = True
-        if httponly:
-            morsel["httponly"] = True
-        if samesite is not None:
-            morsel["samesite"] = samesite
-        if max_age is not None:
-            morsel["max-age"] = str(max_age)
-        if expires is not None:
-            morsel["expires"] = expires
-        self.headers["set-cookie"] = cookie.output(header="").strip()
-
-    @classmethod
-    def from_json(
-        cls,
-        data: Any,
-        status_code: int = 200,
-        headers: Mapping[str, str] | None = None,
-    ) -> "ResponseBase":
-        payload = json_module.dumps(
-            data, ensure_ascii=False, separators=(",", ":"), default=str
-        ).encode("utf-8")
-        hdrs = [("content-type", "application/json; charset=utf-8")]
-        for k, v in (headers or {}).items():
-            hdrs.append((k.lower(), v))
-        return cls(
-            status_code=status_code,
-            headers=hdrs,
-            body=payload,
-            media_type="application/json",
-        )
-
-    @classmethod
-    def html(
-        cls,
-        html: str,
-        status_code: int = 200,
-        headers: Mapping[str, str] | None = None,
-    ) -> "ResponseBase":
-        payload = html.encode("utf-8")
-        hdrs = [("content-type", "text/html; charset=utf-8")]
-        for k, v in (headers or {}).items():
-            hdrs.append((k.lower(), v))
-        return cls(
-            status_code=status_code,
-            headers=hdrs,
-            body=payload,
-            media_type="text/html",
-        )
-
-    @classmethod
-    def text(
-        cls,
-        text: str,
-        status_code: int = 200,
-        headers: Mapping[str, str] | None = None,
-    ) -> "ResponseBase":
-        payload = text.encode("utf-8")
-        hdrs = [("content-type", "text/plain; charset=utf-8")]
-        for k, v in (headers or {}).items():
-            hdrs.append((k.lower(), v))
-        return cls(
-            status_code=status_code,
-            headers=hdrs,
-            body=payload,
-            media_type="text/plain",
-        )
-
-
-@dataclass
-class TemplateBase(TemplateSpec):
-    """Concrete template configuration used at runtime."""

tigrbl-0.3.17.dev11/tigrbl/_base/_schema_base.py

@@ -1,14 +0,0 @@
-from __future__ import annotations
-
-
-class SchemaBase:
-    """Shared schema helpers used by concrete schema wrappers."""
-
-    @classmethod
-    def collect(cls, model: type) -> dict[str, dict[str, type]]:
-        from ..mapping.collect_decorated_schemas import collect_decorated_schemas
-
-        return collect_decorated_schemas(model)
-
-
-__all__ = ["SchemaBase"]

tigrbl-0.3.17.dev11/tigrbl/_base/_security_base.py

@@ -1,69 +0,0 @@
-"""Core OpenAPI security scheme primitives."""
-
-from __future__ import annotations
-
-from typing import Any, Mapping, Sequence
-
-_VALID_SECURITY_SCHEME_TYPES = {
-    "http",
-    "apiKey",
-    "oauth2",
-    "openIdConnect",
-    "mutualTLS",
-}
-
-
-class OpenAPISecurityDependency:
-    """Base security dependency with OpenAPI document metadata."""
-
-    def __init__(
-        self,
-        *,
-        scheme_name: str,
-        scheme: Mapping[str, Any],
-        scopes: Sequence[str] | None = None,
-        auto_error: bool = True,
-    ) -> None:
-        self.scheme_name = scheme_name
-        self.auto_error = auto_error
-        self._scheme = dict(scheme)
-        self._scopes = list(scopes or [])
-        validate_openapi_security_scheme(self._scheme)
-
-    def openapi_security_scheme(self) -> dict[str, Any]:
-        return dict(self._scheme)
-
-    def openapi_security_requirement(self) -> dict[str, list[str]]:
-        return {self.scheme_name: list(self._scopes)}
-
-    def __call__(self, request: Any) -> Any | None:
-        return None
-
-
-def validate_openapi_security_scheme(scheme: Mapping[str, Any]) -> None:
-    scheme_type = scheme.get("type")
-    if scheme_type not in _VALID_SECURITY_SCHEME_TYPES:
-        raise ValueError(
-            "OpenAPI security scheme 'type' must be one of: "
-            f"{sorted(_VALID_SECURITY_SCHEME_TYPES)}"
-        )
-
-    if "scheme" in scheme and scheme_type != "http":
-        raise ValueError("OpenAPI 'scheme' is only valid when type is 'http'.")
-
-    if scheme_type == "http" and not scheme.get("scheme"):
-        raise ValueError("OpenAPI type='http' requires a non-empty 'scheme'.")
-
-    if scheme_type == "apiKey":
-        if scheme.get("in") not in {"header", "query", "cookie"}:
-            raise ValueError(
-                "OpenAPI type='apiKey' requires 'in' to be header/query/cookie."
-            )
-        if not scheme.get("name"):
-            raise ValueError("OpenAPI type='apiKey' requires 'name'.")
-
-    if scheme_type == "oauth2" and not isinstance(scheme.get("flows"), Mapping):
-        raise ValueError("OpenAPI type='oauth2' requires a 'flows' object.")
-
-    if scheme_type == "openIdConnect" and not scheme.get("openIdConnectUrl"):
-        raise ValueError("OpenAPI type='openIdConnect' requires 'openIdConnectUrl'.")

tigrbl-0.3.17.dev11/tigrbl/_base/_session_abc.py

@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Any, Callable
-
-
-class SessionABC(ABC):
-    """Authoritative Tigrbl session interface."""
-
-    @abstractmethod
-    async def begin(self) -> None: ...
-
-    @abstractmethod
-    async def commit(self) -> None: ...
-
-    @abstractmethod
-    async def rollback(self) -> None: ...
-
-    @abstractmethod
-    def in_transaction(self) -> bool: ...
-
-    @abstractmethod
-    async def get(self, model: type, ident: Any) -> Any | None: ...
-
-    @abstractmethod
-    def add(self, obj: Any) -> None: ...
-
-    @abstractmethod
-    async def delete(self, obj: Any) -> None: ...
-
-    @abstractmethod
-    async def flush(self) -> None: ...
-
-    @abstractmethod
-    async def refresh(self, obj: Any) -> None: ...
-
-    @abstractmethod
-    async def execute(self, stmt: Any) -> Any: ...
-
-    @abstractmethod
-    async def close(self) -> None: ...
-
-    @abstractmethod
-    async def run_sync(self, fn: Callable[[Any], Any]) -> Any: ...
-
-
-__all__ = ["SessionABC"]