tigrbl-concrete 0.1.0.dev5__tar.gz

tigrbl_concrete-0.1.0.dev5/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: tigrbl-concrete
+Version: 0.1.0.dev5
+Summary: Concrete implementations of Tigrbl base abstractions.
+License-Expression: Apache-2.0
+Keywords: tigrbl,sdk,standards,framework
+Author: Jacob Stewart
+Author-email: jacob@swarmauri.com
+Requires-Python: >=3.10,<3.13
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Development Status :: 1 - Planning
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Dist: orjson
+Requires-Dist: pydantic (>=2.0)
+Requires-Dist: sqlalchemy
+Requires-Dist: tigrbl-atoms
+Requires-Dist: tigrbl-base
+Requires-Dist: tigrbl-core
+Requires-Dist: tigrbl-ops-oltp
+Requires-Dist: tigrbl-runtime
+Requires-Dist: tigrbl-typing
+Requires-Dist: uvicorn
+Description-Content-Type: text/markdown
+
+![Tigrbl branding](https://github.com/swarmauri/swarmauri-sdk/blob/a170683ecda8ca1c4f912c966d4499649ffb8224/assets/tigrbl.brand.theme.svg)
+
+# tigrbl-concrete
+
+![PyPI - Downloads](https://img.shields.io/pypi/dm/tigrbl-concrete.svg) ![Hits](https://hits.sh/github.com/swarmauri/swarmauri-sdk.svg) ![Python Versions](https://img.shields.io/pypi/pyversions/tigrbl-concrete.svg) ![License](https://img.shields.io/pypi/l/tigrbl-concrete.svg) ![Version](https://img.shields.io/pypi/v/tigrbl-concrete.svg)
+
+## Features
+
+- Modular package in the Tigrbl namespace.
+- Supports Python 3.10 through 3.12.
+- Distributed as part of the swarmauri-sdk workspace.
+
+## Installation
+
+### uv
+
+```bash
+uv add tigrbl-concrete
+```
+
+### pip
+
+```bash
+pip install tigrbl-concrete
+```
+
+## Usage
+
+Import from the shared package-specific module namespaces after installation in your environment.
+
+### Runtime-visible operation metadata
+
+Runtime-visible operations are defined by collected specs (`RouterSpec.collect(...)`,
+`OpSpec.collect(...)`) and then installed through binding on the live graph.
+Mounted routes are not backfilled into runtime metadata after the fact.
+
+```python
+from tigrbl_concrete import TigrblApp, TigrblRouter
+
+app = TigrblApp()
+router = TigrblRouter()
+
+@router.get("/health")
+def health_check():
+    return {"ok": True}
+
+# include_router(...) mounts already-bound operations
+app.include_router(router, prefix="/api")
+```
+

tigrbl_concrete-0.1.0.dev5/README.md

@@ -0,0 +1,49 @@
+![Tigrbl branding](https://github.com/swarmauri/swarmauri-sdk/blob/a170683ecda8ca1c4f912c966d4499649ffb8224/assets/tigrbl.brand.theme.svg)
+
+# tigrbl-concrete
+
+![PyPI - Downloads](https://img.shields.io/pypi/dm/tigrbl-concrete.svg) ![Hits](https://hits.sh/github.com/swarmauri/swarmauri-sdk.svg) ![Python Versions](https://img.shields.io/pypi/pyversions/tigrbl-concrete.svg) ![License](https://img.shields.io/pypi/l/tigrbl-concrete.svg) ![Version](https://img.shields.io/pypi/v/tigrbl-concrete.svg)
+
+## Features
+
+- Modular package in the Tigrbl namespace.
+- Supports Python 3.10 through 3.12.
+- Distributed as part of the swarmauri-sdk workspace.
+
+## Installation
+
+### uv
+
+```bash
+uv add tigrbl-concrete
+```
+
+### pip
+
+```bash
+pip install tigrbl-concrete
+```
+
+## Usage
+
+Import from the shared package-specific module namespaces after installation in your environment.
+
+### Runtime-visible operation metadata
+
+Runtime-visible operations are defined by collected specs (`RouterSpec.collect(...)`,
+`OpSpec.collect(...)`) and then installed through binding on the live graph.
+Mounted routes are not backfilled into runtime metadata after the fact.
+
+```python
+from tigrbl_concrete import TigrblApp, TigrblRouter
+
+app = TigrblApp()
+router = TigrblRouter()
+
+@router.get("/health")
+def health_check():
+    return {"ok": True}
+
+# include_router(...) mounts already-bound operations
+app.include_router(router, prefix="/api")
+```

tigrbl_concrete-0.1.0.dev5/pyproject.toml

@@ -0,0 +1,59 @@
+[project]
+name = "tigrbl-concrete"
+version = "0.1.0.dev5"
+description = "Concrete implementations of Tigrbl base abstractions."
+license = "Apache-2.0"
+readme = "README.md"
+repository = "http://github.com/swarmauri/swarmauri-sdk"
+requires-python = ">=3.10,<3.13"
+classifiers = [
+    "License :: OSI Approved :: Apache Software License",
+    "Development Status :: 1 - Planning",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+]
+authors = [{ name = "Jacob Stewart", email = "jacob@swarmauri.com" }]
+dependencies = [
+    "orjson",
+    "pydantic>=2.0",
+    "sqlalchemy",
+    "tigrbl-atoms",
+    "tigrbl-base",
+    "tigrbl-core",
+    "tigrbl-ops-oltp",
+    "tigrbl-runtime",
+    "tigrbl-typing",
+    "uvicorn",
+]
+keywords = ["tigrbl", "sdk", "standards", "framework"]
+
+[tool.uv.sources]
+"tigrbl-atoms" = { workspace = true }
+"tigrbl-base" = { workspace = true }
+"tigrbl-core" = { workspace = true }
+"tigrbl-ops-oltp" = { workspace = true }
+"tigrbl-runtime" = { workspace = true }
+"tigrbl-typing" = { workspace = true }
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.poetry]
+packages = [
+    { include = "tigrbl_concrete" },
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "ruff>=0.9",
+]
+
+[project.entry-points."tigrbl.engine_plugins"]
+concrete = "tigrbl_concrete.engine.plugins:register"

tigrbl_concrete-0.1.0.dev5/tigrbl_concrete/__init__.py

@@ -0,0 +1,67 @@
+"""tigrbl_concrete compatibility facade.
+
+This package provides concrete implementations while preserving legacy
+submodule paths that still live in ``tigrbl``.
+"""
+
+from __future__ import annotations
+
+from importlib import import_module
+import sys
+
+
+_COMPAT_ALIASES = {
+    "ddl": "tigrbl.ddl",
+    "system": "tigrbl.system",
+    "op": "tigrbl.op",
+    "config": "tigrbl.config",
+    "schema": "tigrbl.schema",
+    "security": "tigrbl.security",
+}
+
+
+def _optional_import(path: str):
+    try:
+        return import_module(path)
+    except ImportError:
+        return None
+
+
+for alias, target in _COMPAT_ALIASES.items():
+    module = _optional_import(target)
+    if module is not None:
+        sys.modules.setdefault(f"{__name__}.{alias}", module)
+
+
+def build_handlers(*args, **kwargs):
+    return import_module("tigrbl_concrete._mapping.model")._materialize_handlers(
+        *args, **kwargs
+    )
+
+
+def build_hooks(*args, **kwargs):
+    return import_module("tigrbl_concrete._mapping.model")._bind_model_hooks(
+        *args, **kwargs
+    )
+
+
+def build_schemas(*args, **kwargs):
+    return import_module("tigrbl_concrete._mapping.model")._materialize_schemas(
+        *args, **kwargs
+    )
+
+
+def build_rest_router(*args, **kwargs):
+    if "router" not in kwargs:
+        kwargs["router"] = None
+    return import_module("tigrbl_concrete._mapping.model")._materialize_rest_router(
+        *args, **kwargs
+    )
+
+
+__all__ = [
+    "build_handlers",
+    "build_hooks",
+    "build_schemas",
+    "build_rest_router",
+]

tigrbl_concrete-0.1.0.dev5/tigrbl_concrete/_concrete/__init__.py

@@ -0,0 +1,59 @@
+"""Concrete generic class implementations for tigrbl."""
+
+from __future__ import annotations
+
+from importlib import import_module
+from typing import Any
+
+_EXPORTS = {
+    "Alias": "_alias",
+    "Binding": "_binding",
+    "BindingRegistry": "_binding",
+    "App": "_app",
+    "Column": "_column",
+    "Engine": "_engine",
+    "Hook": "_hook",
+    "Op": "_op",
+    "Route": "_route",
+    "Router": "_router",
+    "Schema": "_schema",
+    "ForeignKey": "_storage",
+    "StorageTransform": "_storage",
+    "Table": "_table",
+    "Template": "_response",
+    "TableRegistry": "_table_registry",
+    "Response": "_response",
+    "TransportResponse": "_response",
+    "JSONResponse": "_json_response",
+    "HTMLResponse": "_html_response",
+    "PlainTextResponse": "_plain_text_response",
+    "StreamingResponse": "_streaming_response",
+    "DefaultSession": "_session",
+    "FileResponse": "_file_response",
+    "RedirectResponse": "_redirect_response",
+    "Request": "_request",
+    "Body": "_body",
+    "Depends": "dependencies",
+    "APIKey": "_security",
+    "HTTPBearer": "_security",
+    "OAuth2": "_security",
+    "OpenIdConnect": "_security",
+    "MutualTLS": "_security",
+    "TigrblApp": "tigrbl_app",
+    "TigrblRouter": "tigrbl_router",
+    "BackgroundTask": "_background",
+    "wrap_sessionmaker": "_session",
+    "allow_anon": "_allow_anon",
+}
+
+__all__ = list(_EXPORTS)
+
+
+def __getattr__(name: str) -> Any:
+    module_name = _EXPORTS.get(name)
+    if module_name is None:
+        raise AttributeError(name)
+    module = import_module(f"{__name__}.{module_name}")
+    value = getattr(module, name)
+    globals()[name] = value
+    return value

tigrbl_concrete-0.1.0.dev5/tigrbl_concrete/_concrete/_alias.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from tigrbl_base._base import AliasBase
+
+
+class Alias(AliasBase):
+    """Concrete alias type."""
+
+
+__all__ = ["Alias"]

tigrbl_concrete-0.1.0.dev5/tigrbl_concrete/_concrete/_allow_anon.py

@@ -0,0 +1,42 @@
+"""Decorator helpers for anonymous route authorization metadata."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TypeVar
+
+from tigrbl_core.config.constants import TIGRBL_ALLOW_ANON_ATTR
+
+_TableT = TypeVar("_TableT", bound=type)
+
+
+def _normalize_ops(ops: Iterable[str]) -> tuple[str, ...]:
+    normalized = [op.strip() for op in ops if isinstance(op, str) and op.strip()]
+    seen: set[str] = set()
+    deduped: list[str] = []
+    for op in normalized:
+        if op not in seen:
+            seen.add(op)
+            deduped.append(op)
+    return tuple(deduped)
+
+
+def allow_anon(*ops: str):
+    """Attach anonymous-allowed operation names to a table class.
+
+    Example:
+        @allow_anon("list", "read")
+        class Item(TableBase):
+            ...
+    """
+
+    normalized = _normalize_ops(ops)
+
+    def _decorator(table_cls: _TableT) -> _TableT:
+        setattr(table_cls, TIGRBL_ALLOW_ANON_ATTR, normalized)
+        return table_cls
+
+    return _decorator
+
+
+__all__ = ["allow_anon"]

tigrbl_concrete-0.1.0.dev5/tigrbl_concrete/_concrete/_app.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ._table_registry import TableRegistry
+from tigrbl_base._base import AppBase
+from tigrbl_concrete.ddl import initialize as _ddl_initialize
+from ._engine import Engine
+from tigrbl_concrete._concrete import engine_resolver as _resolver
+from tigrbl_core._spec.app_spec import AppSpec
+from tigrbl_core._spec.engine_spec import EngineCfg
+from ._routing import (
+    include_router as _include_router_impl,
+    merge_tags as _merge_tags_impl,
+    normalize_prefix as _normalize_prefix_impl,
+)
+from tigrbl_runtime.runtime import Runtime
+from tigrbl_typing.gw.raw import GwRawEnvelope
+
+
+class App(AppBase):
+    @classmethod
+    def collect(cls) -> AppSpec:
+        """Collect and normalize AppSpec configuration for this App class."""
+        return AppSpec.collect(cls)
+
+    @classmethod
+    def _collect_mro_spec(cls) -> AppSpec:
+        return cls.collect()
+
+    TITLE = "Tigrbl"
+    VERSION = "0.1.0"
+    LIFESPAN = None
+    ROUTERS = ()
+    OPS = ()
+    TABLES = ()
+    SCHEMAS = ()
+    HOOKS = ()
+    DESCRIPTION = None
+    OPENAPI_URL = "/openapi.json"
+    DOCS_URL = "/docs"
+    DEBUG = False
+    SWAGGER_UI_VERSION = "5.31.0"
+    SECURITY_DEPS = ()
+    DEPS = ()
+    RESPONSE = None
+    JSONRPC_PREFIX = "/rpc"
+    SYSTEM_PREFIX = "/system"
+
+    def __init__(self, *, engine: EngineCfg | None = None, **asgi_kwargs: Any) -> None:
+        collected_spec = self.__class__._collect_mro_spec()
+        collected_spec = self.__class__.bind_spec(collected_spec, parent=self)
+
+        title = asgi_kwargs.pop("title", None)
+        if title is not None:
+            self.TITLE = title
+        else:
+            title = collected_spec.title
+        version = asgi_kwargs.pop("version", None)
+        if version is not None:
+            self.VERSION = version
+        else:
+            version = collected_spec.version
+        lifespan = asgi_kwargs.pop("lifespan", None)
+        if lifespan is not None:
+            self.LIFESPAN = lifespan
+        else:
+            lifespan = collected_spec.lifespan
+        get_db = asgi_kwargs.pop("get_db", None)
+        if get_db is not None:
+            self.get_db = get_db
+        description = asgi_kwargs.pop("description", None)
+        if description is None:
+            description = getattr(self, "DESCRIPTION", None)
+        openapi_url = asgi_kwargs.pop("openapi_url", None)
+        if openapi_url is None:
+            openapi_url = getattr(self, "OPENAPI_URL", "/openapi.json")
+        docs_url = asgi_kwargs.pop("docs_url", None)
+        if docs_url is None:
+            docs_url = getattr(self, "DOCS_URL", "/docs")
+        debug = asgi_kwargs.pop("debug", None)
+        if debug is None:
+            debug = bool(getattr(self, "DEBUG", False))
+        swagger_ui_version = asgi_kwargs.pop("swagger_ui_version", None)
+        if swagger_ui_version is None:
+            swagger_ui_version = getattr(self, "SWAGGER_UI_VERSION", "5.31.0")
+        include_docs = asgi_kwargs.pop("include_docs", None)
+        if include_docs is None:
+            include_docs = bool(getattr(self, "INCLUDE_DOCS", False))
+        self.title = title
+        self.version = version
+        self.description = description
+        self.openapi_url = openapi_url
+        self.docs_url = docs_url
+        self.debug = debug
+        self.swagger_ui_version = swagger_ui_version
+        self.engine = engine if engine is not None else collected_spec.engine
+        self.routers = tuple(collected_spec.routers)
+        self.ops = tuple(collected_spec.ops)
+        self.tables = TableRegistry(tables=collected_spec.tables)
+        self.schemas = tuple(collected_spec.schemas)
+        self.hooks = tuple(collected_spec.hooks)
+        self.security_deps = tuple(collected_spec.security_deps)
+        self.deps = tuple(collected_spec.deps)
+        self.response = collected_spec.response
+        self.jsonrpc_prefix = collected_spec.jsonrpc_prefix
+        self.system_prefix = collected_spec.system_prefix
+        self.lifespan = lifespan
+
+        from ._router import Router
+
+        Router.__init__(
+            self,
+            engine=self.engine,
+            title=self.title,
+            version=self.version,
+            description=self.description,
+            openapi_url=self.openapi_url,
+            docs_url=self.docs_url,
+            debug=self.debug,
+            swagger_ui_version=self.swagger_ui_version,
+            include_docs=include_docs,
+            **asgi_kwargs,
+        )
+        # Router.__init__ seeds several attributes from class-level defaults.
+        # Re-apply merged AppSpec values so MRO-collected app configuration
+        # remains the source of truth for the app instance.
+        self.routers = tuple(collected_spec.routers)
+        self.ops = tuple(collected_spec.ops)
+        self.tables = TableRegistry(tables=collected_spec.tables)
+        self.schemas = tuple(collected_spec.schemas)
+        self.hooks = tuple(collected_spec.hooks)
+        self.security_deps = tuple(collected_spec.security_deps)
+        self.deps = tuple(collected_spec.deps)
+        self.response = collected_spec.response
+        self.jsonrpc_prefix = collected_spec.jsonrpc_prefix
+        self.system_prefix = collected_spec.system_prefix
+
+        _engine_ctx = self.engine
+        if _engine_ctx is not None:
+            _resolver.set_default(_engine_ctx)
+            _resolver.resolve_provider()
+
+        self.runtime = Runtime(
+            default_executor=getattr(self, "DEFAULT_EXECUTOR", "packed")
+        )
+
+    @property
+    def router(self) -> "App":
+        return self
+
+    def install_engines(
+        self, *, router: Any = None, tables: tuple[Any, ...] | None = None
+    ) -> None:
+        routers = (router,) if router is not None else self.ROUTERS
+        tables = tables if tables is not None else self.TABLES
+        install_app = self if (routers or tuple(tables)) else None
+        if routers:
+            for a in routers:
+                Engine.install_from_objects(
+                    app=install_app, router=a, tables=tuple(tables)
+                )
+        else:
+            Engine.install_from_objects(
+                app=install_app, router=None, tables=tuple(tables)
+            )
+
+    async def invoke(self, env: GwRawEnvelope) -> None:
+        plan, packed_plan = self.runtime.compile(self)
+        ctx: dict[str, Any] = {
+            "app": self,
+            "router": self,
+            "raw": env,
+            "env": env,
+            "kernel_plan": plan,
+            "plan": plan,
+            "packed_plan": packed_plan,
+            "temp": {},
+        }
+        await self.runtime.invoke(
+            env=env,
+            ctx=ctx,
+            plan=plan,
+            packed_plan=packed_plan,
+        )
+
+    async def __call__(self, scope: dict[str, Any], receive: Any, send: Any) -> None:
+        path = scope.get("path")
+        if isinstance(path, str):
+            seen_paths = getattr(self, "_seen_paths", None)
+            if not isinstance(seen_paths, set):
+                seen_paths = set()
+                setattr(self, "_seen_paths", seen_paths)
+            seen_paths.add(path)
+        env = GwRawEnvelope(kind="asgi3", scope=scope, receive=receive, send=send)
+        await self.invoke(env)
+
+    def _normalize_prefix(self, prefix: str) -> str:
+        return _normalize_prefix_impl(prefix)
+
+    def _merge_tags(self, tags: list[str] | None) -> list[str] | None:
+        return _merge_tags_impl(getattr(self, "tags", None), tags)
+
+    def include_router(self, router: Any, *, prefix: str | None = None) -> Any:
+        routed = getattr(router, "router", router)
+        _include_router_impl(self, routed, prefix=prefix or "")
+        bump = getattr(self, "_bump_runtime_plan_revision", None)
+        if callable(bump):
+            bump()
+        return router
+
+    initialize = _ddl_initialize

tigrbl_concrete-0.1.0.dev5/tigrbl_concrete/_concrete/_background.py

@@ -0,0 +1,29 @@
+"""Background task helpers with Starlette-compatible call behavior."""
+
+from __future__ import annotations
+
+import inspect
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass
+class BackgroundTask:
+    """Run a callable after response handling, matching Starlette semantics."""
+
+    func: Callable[..., Any]
+    args: tuple[Any, ...] = ()
+    kwargs: dict[str, Any] | None = None
+
+    def __init__(self, func: Callable[..., Any], *args: Any, **kwargs: Any) -> None:
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+
+    async def __call__(self) -> None:
+        result = self.func(*self.args, **(self.kwargs or {}))
+        if inspect.isawaitable(result):
+            await result
+
+
+__all__ = ["BackgroundTask"]

tigrbl_concrete-0.1.0.dev5/tigrbl_concrete/_concrete/_binding.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from tigrbl_base._base import BindingBase, BindingRegistryBase
+
+
+class Binding(BindingBase):
+    """Concrete named binding declaration."""
+
+
+class BindingRegistry(BindingRegistryBase):
+    """Concrete named binding registry."""
+
+
+__all__ = ["Binding", "BindingRegistry"]

tigrbl_concrete-0.1.0.dev5/tigrbl_concrete/_concrete/_body.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Body:
+    """Lightweight wrapper for response/request payload bytes."""
+
+    value: bytes | str | None
+
+    def decode(self, encoding: str = "utf-8") -> str:
+        """Decode the wrapped payload into text."""
+        if self.value is None:
+            return ""
+        if isinstance(self.value, bytes):
+            return self.value.decode(encoding)
+        return self.value
+
+    def json(self) -> Any:
+        """Parse the wrapped payload as JSON."""
+        text = self.decode()
+        if not text:
+            return None
+        return json.loads(text)

tigrbl_concrete-0.1.0.dev5/tigrbl_concrete/_concrete/_column.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from tigrbl_base._base import ColumnBase
+
+
+class Column(ColumnBase):
+    """Concrete SQLAlchemy column implementing a :class:`ColumnSpec`."""
+
+
+__all__ = ["Column"]