tigrbl 0.3.2.dev1__py3-none-any.whl → 0.3.3__py3-none-any.whl

tigrbl/api/_api.py

@@ -26,6 +26,11 @@ class Api(APISpec, ApiRouter):
     def __eq__(self, other: object) -> bool:  # pragma: no cover - identity compare
         return self is other
 
+    @property
+    def router(self) -> "Api":  # pragma: no cover - simple alias
+        """Mirror FastAPI-style router access for API instances."""
+        return self
+
     def __init__(
         self, *, engine: EngineCfg | None = None, **router_kwargs: Any
     ) -> None:

tigrbl/api/tigrbl_api.py

@@ -62,6 +62,8 @@ class TigrblApi(_Api):
         self,
         *,
         engine: EngineCfg | None = None,
+        models: Sequence[type] | None = None,
+        prefix: str | None = None,
         jsonrpc_prefix: str = "/rpc",
         system_prefix: str = "/system",
         api_hooks: Mapping[str, Iterable[Callable]]
@@ -69,6 +71,8 @@ class TigrblApi(_Api):
         | None = None,
         **router_kwargs: Any,
     ) -> None:
+        if prefix is not None:
+            self.PREFIX = prefix
         _Api.__init__(self, engine=engine, **router_kwargs)
         self.jsonrpc_prefix = jsonrpc_prefix
         self.system_prefix = system_prefix
@@ -89,6 +93,8 @@ class TigrblApi(_Api):
 
         # 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:
+            self.include_models(list(models))
 
     # ------------------------- internal helpers -------------------------
 

tigrbl/app/_app.py

@@ -12,12 +12,36 @@ from .app_spec import AppSpec
 
 
 class App(AppSpec, FastAPI):
+    TITLE = "Tigrbl"
+    VERSION = "0.1.0"
+    LIFESPAN = None
+    MIDDLEWARES = ()
+    APIS = ()
+    OPS = ()
+    MODELS = ()
+    SCHEMAS = ()
+    HOOKS = ()
+    SECURITY_DEPS = ()
+    DEPS = ()
+    RESPONSE = None
+    JSONRPC_PREFIX = "/rpc"
+    SYSTEM_PREFIX = "/system"
+
     def __init__(
         self, *, engine: EngineCfg | None = None, **fastapi_kwargs: Any
     ) -> None:
         # Manually mirror ``AppSpec`` fields so the dataclass-generated ``repr``
         # and friends have expected attributes while runtime structures remain
         # mutable dictionaries or lists as needed.
+        title = fastapi_kwargs.pop("title", None)
+        if title is not None:
+            self.TITLE = title
+        version = fastapi_kwargs.pop("version", None)
+        if version is not None:
+            self.VERSION = version
+        lifespan = fastapi_kwargs.pop("lifespan", None)
+        if lifespan is not None:
+            self.LIFESPAN = lifespan
         self.title = self.TITLE
         self.version = self.VERSION
         self.engine = engine if engine is not None else getattr(self, "ENGINE", None)

tigrbl/app/mro_collect.py

@@ -9,10 +9,22 @@ from .app_spec import AppSpec
 logger = logging.getLogger("uvicorn")
 
 
-def _merge_seq_attr(app: type, attr: str) -> Tuple[Any, ...]:
+def _merge_seq_attr(
+    app: type,
+    attr: str,
+    *,
+    include_inherited: bool = False,
+    reverse: bool = False,
+) -> Tuple[Any, ...]:
     values: list[Any] = []
-    for base in reversed(app.__mro__):
-        seq = getattr(base, attr, ()) or ()
+    mro = reversed(app.__mro__) if reverse else app.__mro__
+    for base in mro:
+        if include_inherited:
+            if not hasattr(base, attr):
+                continue
+            seq = getattr(base, attr) or ()
+        else:
+            seq = base.__dict__.get(attr, ()) or ()
         try:
             values.extend(seq)
         except TypeError:  # non-iterable
@@ -25,30 +37,57 @@ def mro_collect_app_spec(app: type) -> AppSpec:
     """Collect AppSpec-like declarations across the app's MRO."""
     logger.info("Collecting app spec for %s", app.__name__)
 
-    title = "Tigrbl"
-    version = "0.1.0"
-    engine: Any | None = None
-    response = None
-    jsonrpc_prefix = "/rpc"
-    system_prefix = "/system"
-    lifespan = None
+    sentinel = object()
+    title: Any = sentinel
+    version: Any = sentinel
+    engine: Any | None = sentinel  # type: ignore[assignment]
+    response: Any = sentinel
+    jsonrpc_prefix: Any = sentinel
+    system_prefix: Any = sentinel
+    lifespan: Any = sentinel
 
-    for base in reversed(app.__mro__):
-        title = getattr(base, "TITLE", title)
-        version = getattr(base, "VERSION", version)
-        eng = getattr(base, "ENGINE", None)
-        if eng is not None:
-            engine = eng
-        response = getattr(base, "RESPONSE", response)
-        jsonrpc_prefix = getattr(base, "JSONRPC_PREFIX", jsonrpc_prefix)
-        system_prefix = getattr(base, "SYSTEM_PREFIX", system_prefix)
-        lifespan = getattr(base, "LIFESPAN", lifespan)
+    for base in app.__mro__:
+        if "TITLE" in base.__dict__ and title is sentinel:
+            title = base.__dict__["TITLE"]
+        if "VERSION" in base.__dict__ and version is sentinel:
+            version = base.__dict__["VERSION"]
+        if "ENGINE" in base.__dict__ and engine is sentinel:
+            engine = base.__dict__["ENGINE"]
+        if "RESPONSE" in base.__dict__ and response is sentinel:
+            response = base.__dict__["RESPONSE"]
+        if "JSONRPC_PREFIX" in base.__dict__ and jsonrpc_prefix is sentinel:
+            jsonrpc_prefix = base.__dict__["JSONRPC_PREFIX"]
+        if "SYSTEM_PREFIX" in base.__dict__ and system_prefix is sentinel:
+            system_prefix = base.__dict__["SYSTEM_PREFIX"]
+        if "LIFESPAN" in base.__dict__ and lifespan is sentinel:
+            lifespan = base.__dict__["LIFESPAN"]
 
+    if title is sentinel:
+        title = "Tigrbl"
+    if version is sentinel:
+        version = "0.1.0"
+    if engine is sentinel:
+        engine = None
+    if response is sentinel:
+        response = None
+    if jsonrpc_prefix is sentinel:
+        jsonrpc_prefix = "/rpc"
+    if system_prefix is sentinel:
+        system_prefix = "/system"
+    if lifespan is sentinel:
+        lifespan = None
+
+    include_inherited_apis = "APIS" not in app.__dict__
     spec = AppSpec(
         title=title,
         version=version,
         engine=engine,
-        apis=_merge_seq_attr(app, "APIS"),
+        apis=_merge_seq_attr(
+            app,
+            "APIS",
+            include_inherited=include_inherited_apis,
+            reverse=include_inherited_apis,
+        ),
         ops=_merge_seq_attr(app, "OPS"),
         models=_merge_seq_attr(app, "MODELS"),
         schemas=_merge_seq_attr(app, "SCHEMAS"),

tigrbl/app/tigrbl_app.py

@@ -1,7 +1,9 @@
 # tigrbl/v3/app/tigrbl_app.py
 from __future__ import annotations
 
+import asyncio
 import copy
+import inspect
 from types import SimpleNamespace
 from typing import (
     Any,
@@ -71,6 +73,7 @@ class TigrblApp(_App):
         self,
         *,
         engine: EngineCfg | None = None,
+        apis: Sequence[Any] | None = None,
         jsonrpc_prefix: str = "/rpc",
         system_prefix: str = "/system",
         api_hooks: Mapping[str, Iterable[Callable]]
@@ -106,9 +109,13 @@ class TigrblApp(_App):
         self.table_config: Dict[str, Dict[str, Any]] = {}
         self.core = SimpleNamespace()
         self.core_raw = SimpleNamespace()
+        self.apis = list(getattr(self, "APIS", ()))
 
         # 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 apis:
+            self.apis.extend(list(apis))
+            self.include_apis(self.apis)
 
     # ------------------------- internal helpers -------------------------
 
@@ -175,6 +182,92 @@ class TigrblApp(_App):
             mount_router=mount_router,
         )
 
+    def include_api(
+        self,
+        api: Any,
+        *,
+        prefix: str | None = None,
+        mount_router: bool = True,
+    ) -> Any:
+        """Mount a Tigrbl API router onto this app and track it."""
+        if api not in self.apis:
+            self.apis.append(api)
+        if not mount_router:
+            return api
+        router = getattr(api, "router", api)
+        if hasattr(self, "include_router"):
+            self.include_router(router, prefix=prefix or "")
+        return api
+
+    def include_router(self, router: Any, *args: Any, **kwargs: Any) -> None:
+        """Extend FastAPI include_router to track Tigrbl APIs."""
+        if hasattr(router, "models") and hasattr(router, "initialize"):
+            self.include_api(
+                router,
+                prefix=kwargs.get("prefix"),
+                mount_router=False,
+            )
+        super().include_router(router, *args, **kwargs)
+
+    def include_apis(self, apis: Sequence[Any]) -> None:
+        """Mount multiple APIs, supporting optional per-item prefixes."""
+        for entry in apis:
+            prefix = None
+            api = entry
+            if isinstance(entry, tuple) and entry:
+                api = entry[0]
+                if len(entry) > 1:
+                    value = entry[1]
+                    if isinstance(value, dict):
+                        prefix = value.get("prefix")
+                    elif isinstance(value, str):
+                        prefix = value
+            self.include_api(api, prefix=prefix)
+
+    def initialize(
+        self,
+        *,
+        schemas: Iterable[str] | None = None,
+        sqlite_attachments: Mapping[str, str] | None = None,
+        tables: Iterable[Any] | None = None,
+    ):
+        """Initialize DDL for the app and any attached APIs."""
+        result = _ddl_initialize(
+            self,
+            schemas=schemas,
+            sqlite_attachments=sqlite_attachments,
+            tables=tables,
+        )
+
+        api_results = []
+        for api in self.apis:
+            init = getattr(api, "initialize", None)
+            if callable(init):
+                api_results.append(
+                    init(
+                        schemas=schemas,
+                        sqlite_attachments=sqlite_attachments,
+                        tables=tables,
+                    )
+                )
+
+        awaitables = [r for r in [result, *api_results] if inspect.isawaitable(r)]
+        if not awaitables:
+            return None
+
+        async def _inner():
+            for item in [result, *api_results]:
+                if inspect.isawaitable(item):
+                    await item
+
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            asyncio.run(_inner())
+            return None
+
+        return loop.create_task(_inner())
+
     async def rpc_call(
         self,
         model_or_name: type | str,
@@ -311,8 +404,6 @@ class TigrblApp(_App):
                 tables.append(t)
         return tables
 
-    initialize = _ddl_initialize
-
     # ------------------------- repr -------------------------
 
     def __repr__(self) -> str:  # pragma: no cover

tigrbl/bindings/model_helpers.py

@@ -24,40 +24,40 @@ def _ensure_model_namespaces(model: type) -> None:
     """Create top-level namespaces on the model class if missing."""
 
     # op indexes & metadata
-    if not hasattr(model, "ops"):
-        if hasattr(model, "opspecs"):
+    if "ops" not in model.__dict__:
+        if "opspecs" in model.__dict__:
             model.ops = model.opspecs
         else:
             model.ops = SimpleNamespace(all=(), by_key={}, by_alias={})
     # Backwards compatibility: older code may still expect `model.opspecs`
     model.opspecs = model.ops
     # pydantic schemas: .<alias>.in_ / .<alias>.out
-    if not hasattr(model, "schemas"):
+    if "schemas" not in model.__dict__:
         model.schemas = SimpleNamespace()
     # hooks: phase chains & raw hook descriptors if you want to expose them
-    if not hasattr(model, "hooks"):
+    if "hooks" not in model.__dict__:
         model.hooks = SimpleNamespace()
     # handlers: .<alias>.raw (core/custom), .<alias>.handler (HANDLER chain entry point)
-    if not hasattr(model, "handlers"):
+    if "handlers" not in model.__dict__:
         model.handlers = SimpleNamespace()
     # rpc: callables to be registered/mounted elsewhere as JSON-RPC methods
-    if not hasattr(model, "rpc"):
+    if "rpc" not in model.__dict__:
         model.rpc = SimpleNamespace()
     # rest: .router (FastAPI Router or compatible) – built in rest binding
-    if not hasattr(model, "rest"):
+    if "rest" not in model.__dict__:
         model.rest = SimpleNamespace(router=None)
     # basic table metadata for convenience (introspective only; NEVER used for HTTP paths)
-    if not hasattr(model, "columns"):
+    if "columns" not in model.__dict__:
         table = getattr(model, "__table__", None)
         cols = tuple(getattr(table, "columns", ()) or ())
         model.columns = tuple(
             getattr(c, "name", None) for c in cols if getattr(c, "name", None)
         )
-    if not hasattr(model, "table_config"):
+    if "table_config" not in model.__dict__:
         table = getattr(model, "__table__", None)
         model.table_config = dict(getattr(table, "kwargs", {}) or {})
     # ensure raw hook store exists for decorator merges
-    if not hasattr(model, "__tigrbl_hooks__"):
+    if "__tigrbl_hooks__" not in model.__dict__:
         setattr(model, "__tigrbl_hooks__", {})
 
 

tigrbl/bindings/rest/collection.py

@@ -178,7 +178,79 @@ def _make_collection_endpoint(
         _endpoint.__signature__ = inspect.Signature(params)
     else:
         body_model = _request_model_for(sp, model)
+        if body_model is None and sp.request_model is None and target == "custom":
+
+            async def _endpoint(
+                request: Request,
+                db: Any = Depends(db_dep),
+                h: Mapping[str, Any] = Depends(hdr_dep),
+                **kw: Any,
+            ):
+                parent_kw = {k: kw[k] for k in nested_vars if k in kw}
+                _coerce_parent_kw(model, parent_kw)
+                payload: Mapping[str, Any] = dict(parent_kw)
+                if isinstance(h, Mapping):
+                    payload = {**payload, **dict(h)}
+                ctx = _ctx(model, alias, target, request, db, payload, parent_kw, api)
+
+                def _serializer(r, _ctx=ctx):
+                    out = _serialize_output(model, alias, target, sp, r)
+                    temp = (
+                        getattr(_ctx, "temp", {}) if isinstance(_ctx, Mapping) else {}
+                    )
+                    extras = (
+                        temp.get("response_extras", {})
+                        if isinstance(temp, Mapping)
+                        else {}
+                    )
+                    if isinstance(out, dict) and isinstance(extras, dict):
+                        out.update(extras)
+                    return out
+
+                ctx["response_serializer"] = _serializer
+                phases = _get_phase_chains(model, alias)
+                result = await _executor._invoke(
+                    request=request,
+                    db=db,
+                    phases=phases,
+                    ctx=ctx,
+                )
+                return result
+
+            _endpoint.__signature__ = _sig(
+                nested_vars,
+                [
+                    inspect.Parameter(
+                        "request",
+                        inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                        annotation=Request,
+                    ),
+                    inspect.Parameter(
+                        "db",
+                        inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                        annotation=Annotated[Any, Depends(db_dep)],
+                    ),
+                    inspect.Parameter(
+                        "h",
+                        inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                        annotation=Annotated[Mapping[str, Any], Depends(hdr_dep)],
+                    ),
+                ],
+            )
+            _endpoint.__name__ = f"rest_{model.__name__}_{alias}_collection"
+            _endpoint.__qualname__ = _endpoint.__name__
+            _endpoint.__doc__ = (
+                f"REST collection endpoint for {model.__name__}.{alias} ({target})"
+            )
+            return _endpoint
+
         base = body_model or Mapping[str, Any]
+        body_required = target in {
+            "create",
+            "update",
+            "replace",
+            "merge",
+        } or target.startswith("bulk_")
         if target.startswith("bulk_"):
             alias_ns = getattr(
                 getattr(model, "schemas", None) or SimpleNamespace(), alias, None
@@ -197,13 +269,13 @@ def _make_collection_endpoint(
                 _list_ann(Mapping[str, Any]),
             )
         else:
-            body_annotation = base
+            body_annotation = _union(base, type(None)) if not body_required else base
 
         async def _endpoint(
             request: Request,
             db: Any = Depends(db_dep),
             h: Mapping[str, Any] = Depends(hdr_dep),
-            body=Body(...),
+            body=None,
             **kw: Any,
         ):
             parent_kw = {k: kw[k] for k in nested_vars if k in kw}
@@ -251,6 +323,7 @@ def _make_collection_endpoint(
                 return result
             return result
 
+        body_default = ... if body_required else None
         _endpoint.__signature__ = _sig(
             nested_vars,
             [
@@ -272,7 +345,8 @@ def _make_collection_endpoint(
                 inspect.Parameter(
                     "body",
                     inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                    annotation=Annotated[body_annotation, Body(...)],
+                    annotation=Annotated[body_annotation, Body()],
+                    default=body_default,
                 ),
             ],
         )

tigrbl/bindings/rest/member.py

@@ -134,7 +134,7 @@ def _make_member_endpoint(
         params.extend(
             [
                 inspect.Parameter(
-                    "item_id",
+                    pk_param,
                     inspect.Parameter.POSITIONAL_OR_KEYWORD,
                     annotation=Annotated[Any, Path(...)],
                 ),
@@ -230,7 +230,7 @@ def _make_member_endpoint(
         params.extend(
             [
                 inspect.Parameter(
-                    "item_id",
+                    pk_param,
                     inspect.Parameter.POSITIONAL_OR_KEYWORD,
                     annotation=Annotated[Any, Path(...)],
                 ),
@@ -350,7 +350,7 @@ def _make_member_endpoint(
     params.extend(
         [
             inspect.Parameter(
-                "item_id",
+                pk_param,
                 inspect.Parameter.POSITIONAL_OR_KEYWORD,
                 annotation=Annotated[Any, Path(...)],
             ),

tigrbl/column/field_spec.py

@@ -15,16 +15,17 @@ class FieldSpec:
     ``py_type`` denotes the expected Python type and may be omitted when the
     model attribute is annotated; the type will then be inferred. ``constraints``
     mirrors arguments accepted by :func:`pydantic.Field` and participates in
-    schema generation. ``required_in`` and ``allow_null_in`` govern which API
-    verbs must supply the value or may explicitly send ``null`` in requests.
-    Responses rely on Pydantic's built-in encoders based solely on the
-    declared type.
+    schema generation. ``description`` provides a convenience field for schema
+    metadata. ``required_in`` and ``allow_null_in`` govern which API verbs must
+    supply the value or may explicitly send ``null`` in requests. Responses rely
+    on Pydantic's built-in encoders based solely on the declared type.
     """
 
     py_type: Any = Any
 
     # For request/response schema generation (+ pydantic.Field)
     constraints: Dict[str, Any] = dc_field(default_factory=dict)
+    description: str | None = None
 
     # Request policy (DB nullability lives in StorageSpec.nullable)
     required_in: Tuple[str, ...] = ()

tigrbl/column/shortcuts.py

@@ -64,10 +64,21 @@ def makeVirtualColumn(
 ) -> Column:
     """Convenience for wire-only virtual columns."""
     if spec is not None:
-        if any(
-            x is not None for x in (field, io, default_factory, producer, read_producer)
-        ):
+        if any(x is not None for x in (field, io, default_factory)):
             raise ValueError("Provide either spec or individual components, not both.")
+        if producer is not None and read_producer is not None:
+            raise ValueError(
+                "Provide only one of producer= or read_producer=, not both."
+            )
+        rp = read_producer or producer
+        if rp is not None:
+            spec = ColumnSpec(
+                storage=spec.storage,
+                field=spec.field,
+                io=spec.io,
+                default_factory=spec.default_factory,
+                read_producer=rp,
+            )
         return Column(spec=spec, **kw)
     if producer is not None and read_producer is not None:
         raise ValueError("Provide only one of producer= or read_producer=, not both.")

tigrbl/response/__init__.py

@@ -1,4 +1,8 @@
-from .decorators import response_ctx, get_attached_response_spec
+from .decorators import (
+    response_ctx,
+    get_attached_response_spec,
+    get_attached_response_alias,
+)
 from .types import (
     Response,
     ResponseKind,
@@ -14,6 +18,7 @@ from ..runtime.atoms.response.templates import render_template
 __all__ = [
     "response_ctx",
     "get_attached_response_spec",
+    "get_attached_response_alias",
     "ResponseSpec",
     "ResponseKind",
     "TemplateSpec",

tigrbl/response/decorators.py

@@ -5,6 +5,7 @@ from .types import ResponseSpec
 
 T = TypeVar("T")
 _ATTR = "__tigrbl_response_spec__"
+_ALIAS_ATTR = "__tigrbl_response_alias__"
 
 
 def _to_spec(spec: Optional[ResponseSpec] = None, **kwargs: Any) -> ResponseSpec:
@@ -24,10 +25,13 @@ def response_ctx(**kwargs: Any) -> Callable[[T], T]: ...
 
 
 def response_ctx(*args: Any, **kwargs: Any) -> Callable[[T], T]:
+    alias = kwargs.pop("alias", None)
     spec = _to_spec(*args, **kwargs)
 
     def decorator(target: T) -> T:
         setattr(target, _ATTR, spec)
+        if alias is not None:
+            setattr(target, _ALIAS_ATTR, alias)
         return target
 
     return decorator
@@ -35,3 +39,7 @@ def response_ctx(*args: Any, **kwargs: Any) -> Callable[[T], T]:
 
 def get_attached_response_spec(obj: Any) -> Optional[ResponseSpec]:
     return getattr(obj, _ATTR, None)
+
+
+def get_attached_response_alias(obj: Any) -> Optional[str]:
+    return getattr(obj, _ALIAS_ATTR, None)

tigrbl/schema/builder/build_schema.py

@@ -98,6 +98,9 @@ def _build_schema(
         # Field construction (collect kwargs then create Field once)
         fs = getattr(spec, "field", None)
         field_kwargs: Dict[str, Any] = dict(getattr(fs, "constraints", {}) or {})
+        description = getattr(fs, "description", None)
+        if description and "description" not in field_kwargs:
+            field_kwargs["description"] = description
 
         default_factory = getattr(spec, "default_factory", None)
         if default_factory and verb in set(getattr(io, "in_verbs", []) or []):
@@ -163,6 +166,9 @@ def _build_schema(
         allow_null = bool(fs and verb in getattr(fs, "allow_null_in", ()))
         nullable = bool(getattr(spec, "nullable", True))
         field_kwargs: Dict[str, Any] = dict(getattr(fs, "constraints", {}) or {})
+        description = getattr(fs, "description", None)
+        if description and "description" not in field_kwargs:
+            field_kwargs["description"] = description
 
         default_factory = getattr(spec, "default_factory", None)
         if default_factory and verb in set(getattr(spec.io, "in_verbs", []) or []):

tigrbl/system/diagnostics/hookz.py

@@ -43,8 +43,7 @@ def build_hookz_endpoint(api: Any):
                         phase_map[ph] = [_label_callable(fn) for fn in steps]
                 if phase_map:
                     model_map[alias] = phase_map
-            if model_map:
-                out[mname] = model_map
+            out[mname] = model_map
         cache = out
         return cache
 

tigrbl/system/diagnostics/methodz.py

@@ -15,29 +15,29 @@ def build_methodz_endpoint(api: Any):
         from . import _model_iter, _opspecs
 
         methods: List[Dict[str, Any]] = []
+        per_model: Dict[str, List[Dict[str, Any]]] = {}
         for model in _model_iter(api):
             mname = getattr(model, "__name__", "Model")
             for sp in _opspecs(model):
                 if not getattr(sp, "expose_rpc", True):
                     continue
-                methods.append(
-                    {
-                        "method": f"{mname}.{sp.alias}",
-                        "model": mname,
-                        "alias": sp.alias,
-                        "target": sp.target,
-                        "arity": sp.arity,
-                        "persist": sp.persist,
-                        "request_model": getattr(sp, "request_model", None) is not None,
-                        "response_model": getattr(sp, "response_model", None)
-                        is not None,
-                        "routes": bool(getattr(sp, "expose_routes", True)),
-                        "rpc": bool(getattr(sp, "expose_rpc", True)),
-                        "tags": list(getattr(sp, "tags", ()) or (mname,)),
-                    }
-                )
+                entry = {
+                    "method": f"{mname}.{sp.alias}",
+                    "model": mname,
+                    "alias": sp.alias,
+                    "target": sp.target,
+                    "arity": sp.arity,
+                    "persist": sp.persist,
+                    "request_model": getattr(sp, "request_model", None) is not None,
+                    "response_model": getattr(sp, "response_model", None) is not None,
+                    "routes": bool(getattr(sp, "expose_routes", True)),
+                    "rpc": bool(getattr(sp, "expose_rpc", True)),
+                    "tags": list(getattr(sp, "tags", ()) or (mname,)),
+                }
+                methods.append(entry)
+                per_model.setdefault(mname, []).append(entry)
         methods.sort(key=lambda x: (x["model"], x["alias"]))
-        cache = {"methods": methods}
+        cache = {"methods": methods, **per_model}
         return cache
 
     return _methodz

tigrbl/table/_base.py

@@ -90,7 +90,7 @@ def _instantiate_dtype(
             return dtype
 
 
-def _materialize_colspecs_to_sqla(cls) -> None:
+def _materialize_colspecs_to_sqla(cls, *, map_columns: bool = True) -> None:
     """
     Replace ColumnSpec attributes with sqlalchemy.orm.mapped_column(...) BEFORE mapping.
     Keep the original specs in __tigrbl_cols__ for downstream builders.
@@ -100,9 +100,10 @@ def _materialize_colspecs_to_sqla(cls) -> None:
     except Exception:
         return
     try:
-        from sqlalchemy.orm import InstrumentedAttribute
+        from sqlalchemy.orm import InstrumentedAttribute, MappedColumn
     except Exception:  # pragma: no cover - defensive for minimal SQLA envs
         InstrumentedAttribute = None
+        MappedColumn = None
 
     # Prefer explicit registry if present; otherwise collect specs from the
     # entire MRO so mixins contribute their ColumnSpec definitions.
@@ -119,61 +120,124 @@ def _materialize_colspecs_to_sqla(cls) -> None:
     if not specs:
         return
 
+    if map_columns:
+        for name, spec in specs.items():
+            storage = getattr(spec, "storage", None)
+            if not storage:
+                # Virtual (wire-only) column – ensure SQLAlchemy ignores it.
+                if MappedColumn is not None and isinstance(spec, MappedColumn):
+                    annotations = getattr(cls, "__annotations__", {}) or {}
+                    if name not in annotations:
+                        replacement = ColumnSpec(
+                            storage=None,
+                            field=getattr(spec, "field", None),
+                            io=getattr(spec, "io", None),
+                            default_factory=getattr(spec, "default_factory", None),
+                            read_producer=getattr(spec, "read_producer", None),
+                        )
+                        setattr(cls, name, replacement)
+                        specs[name] = replacement
+                continue
+            existing_attr = getattr(cls, name, None)
+            if InstrumentedAttribute is not None and isinstance(
+                existing_attr, InstrumentedAttribute
+            ):
+                # Column already mapped on a base class; avoid duplicating columns
+                # that trigger SQLAlchemy implicit combination warnings.
+                continue
+
+            dtype = getattr(storage, "type_", None)
+            if not dtype:
+                # No SA dtype specified – cannot materialize
+                continue
+
+            py_type = _infer_py_type(cls, name, spec)
+            dtype_inst = _instantiate_dtype(dtype, py_type, spec, cls.__name__, name)
+
+            # Foreign key (if any)
+            fk = getattr(storage, "fk", None)
+            fk_arg = None
+            if fk is not None:
+                # ForeignKeySpec: target="table(col)", on_delete/on_update: "CASCADE"/...
+                fk_arg = ForeignKey(
+                    fk.target, ondelete=fk.on_delete, onupdate=fk.on_update
+                )
+
+            check = getattr(storage, "check", None)
+            args: list[Any] = []
+            if fk_arg is not None:
+                args.append(fk_arg)
+            if check is not None:
+                cname = f"ck_{cls.__name__.lower()}_{name}"
+                args.append(CheckConstraint(check, name=cname))
+
+            # Build mapped_column from StorageSpec flags
+            mc = mapped_column(
+                dtype_inst,
+                *args,
+                primary_key=getattr(storage, "primary_key", False),
+                nullable=getattr(storage, "nullable", True),
+                unique=getattr(storage, "unique", False),
+                index=getattr(storage, "index", False),
+                default=getattr(storage, "default", None),
+                onupdate=getattr(storage, "onupdate", None),
+                server_default=getattr(storage, "server_default", None),
+                comment=getattr(storage, "comment", None),
+                autoincrement=getattr(storage, "autoincrement", None),
+            )
+
+            setattr(cls, name, mc)
+
     # Ensure downstream code can find the spec map
     setattr(cls, "__tigrbl_cols__", dict(specs))
 
-    for name, spec in specs.items():
-        storage = getattr(spec, "storage", None)
-        if not storage:
-            # Virtual (wire-only) column – no DB column
-            continue
-        existing_attr = getattr(cls, name, None)
-        if InstrumentedAttribute is not None and isinstance(
-            existing_attr, InstrumentedAttribute
-        ):
-            # Column already mapped on a base class; avoid duplicating columns
-            # that trigger SQLAlchemy implicit combination warnings.
-            continue
 
-        dtype = getattr(storage, "type_", None)
-        if not dtype:
-            # No SA dtype specified – cannot materialize
-            continue
+def _ensure_instrumented_attr_accessors() -> None:
+    """Expose ColumnSpec metadata on SQLAlchemy InstrumentedAttribute objects."""
+    try:
+        from sqlalchemy.orm.attributes import InstrumentedAttribute
+    except Exception:  # pragma: no cover - defensive for minimal SQLA envs
+        return
 
-        py_type = _infer_py_type(cls, name, spec)
-        dtype_inst = _instantiate_dtype(dtype, py_type, spec, cls.__name__, name)
-
-        # Foreign key (if any)
-        fk = getattr(storage, "fk", None)
-        fk_arg = None
-        if fk is not None:
-            # ForeignKeySpec: target="table(col)", on_delete/on_update: "CASCADE"/...
-            fk_arg = ForeignKey(fk.target, ondelete=fk.on_delete, onupdate=fk.on_update)
-
-        check = getattr(storage, "check", None)
-        args: list[Any] = []
-        if fk_arg is not None:
-            args.append(fk_arg)
-        if check is not None:
-            cname = f"ck_{cls.__name__.lower()}_{name}"
-            args.append(CheckConstraint(check, name=cname))
-
-        # Build mapped_column from StorageSpec flags
-        mc = mapped_column(
-            dtype_inst,
-            *args,
-            primary_key=getattr(storage, "primary_key", False),
-            nullable=getattr(storage, "nullable", True),
-            unique=getattr(storage, "unique", False),
-            index=getattr(storage, "index", False),
-            default=getattr(storage, "default", None),
-            onupdate=getattr(storage, "onupdate", None),
-            server_default=getattr(storage, "server_default", None),
-            comment=getattr(storage, "comment", None),
-            autoincrement=getattr(storage, "autoincrement", None),
-        )
+    if not hasattr(InstrumentedAttribute, "storage"):
+
+        def _storage(self):  # type: ignore[no-untyped-def]
+            spec = getattr(self.class_, "__tigrbl_cols__", {}).get(self.key)
+            return getattr(spec, "storage", None)
+
+        InstrumentedAttribute.storage = property(_storage)  # type: ignore[attr-defined]
+
+    if not hasattr(InstrumentedAttribute, "field"):
+
+        def _field(self):  # type: ignore[no-untyped-def]
+            spec = getattr(self.class_, "__tigrbl_cols__", {}).get(self.key)
+            return getattr(spec, "field", None)
+
+        InstrumentedAttribute.field = property(_field)  # type: ignore[attr-defined]
+
+    if not hasattr(InstrumentedAttribute, "io"):
 
-        setattr(cls, name, mc)
+        def _io(self):  # type: ignore[no-untyped-def]
+            spec = getattr(self.class_, "__tigrbl_cols__", {}).get(self.key)
+            return getattr(spec, "io", None)
+
+        InstrumentedAttribute.io = property(_io)  # type: ignore[attr-defined]
+
+    if not hasattr(InstrumentedAttribute, "default_factory"):
+
+        def _default_factory(self):  # type: ignore[no-untyped-def]
+            spec = getattr(self.class_, "__tigrbl_cols__", {}).get(self.key)
+            return getattr(spec, "default_factory", None)
+
+        InstrumentedAttribute.default_factory = property(_default_factory)  # type: ignore[attr-defined]
+
+    if not hasattr(InstrumentedAttribute, "read_producer"):
+
+        def _read_producer(self):  # type: ignore[no-untyped-def]
+            spec = getattr(self.class_, "__tigrbl_cols__", {}).get(self.key)
+            return getattr(spec, "read_producer", None)
+
+        InstrumentedAttribute.read_producer = property(_read_producer)  # type: ignore[attr-defined]
 
 
 # ──────────────────────────────────────────────────────────────────────────────
@@ -188,16 +252,27 @@ class Base(DeclarativeBase):
         # 0) Remove any previously registered class with the same module path.
         try:
             reg = Base.registry._class_registry
-            key = f"{cls.__module__}.{cls.__name__}"
-            existing = reg.get(key)
+            name = cls.__name__
+            existing = reg.get(name)
             if existing is not None:
                 try:
                     Base.registry._dispose_cls(existing)
                 except Exception:
                     pass
-                reg.pop(key, None)
-                if reg.get(cls.__name__) is existing:
-                    reg.pop(cls.__name__, None)
+                reg.pop(name, None)
+            module_reg = reg.get("_sa_module_registry")
+            if module_reg is not None:
+                marker = module_reg
+                for part in cls.__module__.split("."):
+                    contents = getattr(marker, "contents", None)
+                    if not isinstance(contents, dict) or part not in contents:
+                        marker = None
+                        break
+                    marker = contents.get(part)
+                if marker is not None and isinstance(
+                    getattr(marker, "contents", None), dict
+                ):
+                    marker.contents.pop(name, None)
         except Exception:
             pass
 
@@ -223,12 +298,105 @@ class Base(DeclarativeBase):
         except Exception:
             pass
 
-        # 1) BEFORE SQLAlchemy maps: turn ColumnSpecs into real mapped_column(...)
-        _materialize_colspecs_to_sqla(cls)
+        # 1) Determine whether this class should be mapped.
+        try:
+            from sqlalchemy import Column as _SAColumn
+            from sqlalchemy.orm import MappedColumn as _MappedColumn
+        except Exception:  # pragma: no cover - defensive
+            _SAColumn = None
+            _MappedColumn = None
+
+        def _has_mappable_columns() -> bool:
+            for base in cls.__mro__:
+                for attr in getattr(base, "__dict__", {}).values():
+                    if _SAColumn is not None and isinstance(attr, _SAColumn):
+                        return True
+                    if _MappedColumn is not None and isinstance(attr, _MappedColumn):
+                        return True
+                    storage = getattr(attr, "storage", None)
+                    if storage is not None:
+                        return True
+                mapping = getattr(base, "__tigrbl_cols__", None)
+                if isinstance(mapping, dict):
+                    for spec in mapping.values():
+                        if _MappedColumn is not None and isinstance(
+                            spec, _MappedColumn
+                        ):
+                            return True
+                        storage = getattr(spec, "storage", None)
+                        if storage is not None:
+                            return True
+            return False
+
+        def _has_primary_key() -> bool:
+            mapper_args = getattr(cls, "__mapper_args__", None)
+            if isinstance(mapper_args, dict) and mapper_args.get("primary_key"):
+                return True
+            for base in cls.__mro__:
+                for attr in getattr(base, "__dict__", {}).values():
+                    if _SAColumn is not None and isinstance(attr, _SAColumn):
+                        if getattr(attr, "primary_key", False):
+                            return True
+                    if _MappedColumn is not None and isinstance(attr, _MappedColumn):
+                        if getattr(attr, "primary_key", False):
+                            return True
+                    storage = getattr(attr, "storage", None)
+                    if storage is not None and getattr(storage, "primary_key", False):
+                        return True
+                mapping = getattr(base, "__tigrbl_cols__", None)
+                if isinstance(mapping, dict):
+                    for spec in mapping.values():
+                        storage = getattr(spec, "storage", None)
+                        if storage is not None and getattr(
+                            storage, "primary_key", False
+                        ):
+                            return True
+            return False
+
+        explicit_abstract = "__abstract__" in cls.__dict__
+        if not explicit_abstract:
+            if not _has_mappable_columns() or not _has_primary_key():
+                cls.__abstract__ = True
+            else:
+                cls.__abstract__ = False
+
+        should_map = not getattr(cls, "__abstract__", False)
+
+        # 1.5) BEFORE SQLAlchemy maps: turn ColumnSpecs into real mapped_column(...)
+        _materialize_colspecs_to_sqla(cls, map_columns=should_map)
+        _ensure_instrumented_attr_accessors()
 
         # 2) Let SQLAlchemy map the class (PK now exists)
         super().__init_subclass__(**kw)
 
+        # 2.5) Surface ctx-only op declarations for lightweight introspection.
+        if not hasattr(cls, "__tigrbl_ops__"):
+            for attr in cls.__dict__.values():
+                target = getattr(attr, "__func__", attr)
+                if getattr(target, "__tigrbl_op_decl__", None) is not None:
+                    cls.__tigrbl_ops__ = tuple()
+                    break
+
+        # 2.6) Collect response specs declared via @response_ctx
+        try:
+            from tigrbl.response import (
+                get_attached_response_spec,
+                get_attached_response_alias,
+            )
+
+            responses = {}
+            for name, obj in cls.__dict__.items():
+                spec = get_attached_response_spec(obj)
+                if spec is None:
+                    continue
+                alias = get_attached_response_alias(obj) or name
+                responses[alias] = spec
+            if responses:
+                cls.responses = responses
+                cls.response = next(iter(responses.values()))
+        except Exception:
+            pass
+
         # 3) Seed model namespaces / index specs (ops/hooks/etc.) – idempotent
         try:
             from tigrbl.bindings import model as _model_bind

tigrbl/table/mro_collect.py

@@ -26,15 +26,30 @@ def mro_collect_table_spec(model: type) -> TableSpec:
 
     Merges common spec attributes (OPS, COLUMNS, SCHEMAS, HOOKS, SECURITY_DEPS,
     DEPS) declared on the class or any mixins. Engine bindings declared via
-    ``table_config`` use the same precedence: later classes in the MRO override
-    earlier ones.
+    ``table_config`` prefer the last inherited binding in the MRO (from
+    wrapper classes) and otherwise fall back to the first direct binding.
     """
 
     logger.info("Collecting table spec for %s", model.__name__)
 
-    engine: Any | None = None
+    direct_engine: Any | None = None
+    inherited_engine: Any | None = None
     for base in model.__mro__:
-        cfg = base.__dict__.get("table_config")
+        if "table_config" in base.__dict__:
+            cfg = base.__dict__.get("table_config")
+            if isinstance(cfg, Mapping):
+                eng = (
+                    cfg.get("engine")
+                    or cfg.get("db")
+                    or cfg.get("database")
+                    or cfg.get("engine_provider")
+                    or cfg.get("db_provider")
+                )
+                if eng is not None and direct_engine is None:
+                    direct_engine = eng
+            continue
+
+        cfg = getattr(base, "table_config", None)
         if isinstance(cfg, Mapping):
             eng = (
                 cfg.get("engine")
@@ -44,7 +59,9 @@ def mro_collect_table_spec(model: type) -> TableSpec:
                 or cfg.get("db_provider")
             )
             if eng is not None:
-                engine = eng
+                inherited_engine = eng
+
+    engine = inherited_engine if inherited_engine is not None else direct_engine
 
     spec = TableSpec(
         model=model,

tigrbl/types/__init__.py

@@ -45,6 +45,7 @@ from ..deps.sqlalchemy import (
     StaticPool,
 )
 
+
 from ..deps.pydantic import (
     BaseModel,
     Field,

{tigrbl-0.3.2.dev1.dist-info → tigrbl-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl
-Version: 0.3.2.dev1
+Version: 0.3.3
 Summary: Automatic API generation tools by Swarmauri.
 License-Expression: Apache-2.0
 License-File: LICENSE

{tigrbl-0.3.2.dev1.dist-info → tigrbl-0.3.3.dist-info}/RECORD

@@ -1,18 +1,18 @@
 tigrbl/README.md,sha256=ed4kzQZJ44MkqbWEcFDFVQC6wbuMY7KkFlWmm4YCEgg,3753
 tigrbl/__init__.py,sha256=9Sx1PgBOHRcu5mo001oENxKhCuJEEZjpnyISYJjJOrg,4286
 tigrbl/api/__init__.py,sha256=iU8usWi_Xa5brbyYsFqLV06Ad9vTXFuVsyN7NFyyuY4,137
-tigrbl/api/_api.py,sha256=dMWJfCC8YVrzY7pzGetm0xxBqC7FGuw_QPFeiH1nKP8,3840
+tigrbl/api/_api.py,sha256=tyDVhhfw6J8gkNcjffA9YZh12w42xwmn5rz2O0NNMvI,4009
 tigrbl/api/api_spec.py,sha256=ESSts5TW2pb4a9wU9H6drmKeU7YbZwx_xPaQ54RFuR4,991
 tigrbl/api/mro_collect.py,sha256=V9U62GsBKDJ0R0N-8f2lVAEpjaO7i74LUcNliwnW-Co,1598
 tigrbl/api/shortcuts.py,sha256=_Ha6yQilo8siXQrSd3ALiK6IzFmgL_OePqs5gy9bFRs,1454
-tigrbl/api/tigrbl_api.py,sha256=UKSvSLaG7vzmM5r39iyNWUslUMiN6eWZlJtXyW5K4Ak,10704
+tigrbl/api/tigrbl_api.py,sha256=ZEAj8vTtMU8JA2Ea1sQYC8vQbAYRfZk_xM8Y-3L_Yh0,10914
 tigrbl/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tigrbl/app/_app.py,sha256=bsg58JEbnLpjBJvvjLayHKGZvrYL7434tTiLZhx1jyY,3596
+tigrbl/app/_app.py,sha256=BXEMETNBK6Wj3wB7U2LhsYhUNftenGcyGMJQLAtLjDE,4229
 tigrbl/app/_model_registry.py,sha256=v6UoDd7hmv5J4DpNEV13BOgIKIcKou10w3zyZVPd-po,1506
 tigrbl/app/app_spec.py,sha256=RzVHibgoIyQQtlQzRtrWDa4pSD7PpWsysgfztJ1tSRY,1474
-tigrbl/app/mro_collect.py,sha256=JfmkAnUGLgVVaevAjVU9O_8JMyJAYiTXTmrxW4EdPx8,2025
+tigrbl/app/mro_collect.py,sha256=W-kOoKGUSW9dtsKaPuMkN5sLBw_0-H8MTqps1KPwPyI,3351
 tigrbl/app/shortcuts.py,sha256=PEMbmwaqW8a3jkcHM5AXsYA2mmuXGFpOTnqlJnUX9Lo,1775
-tigrbl/app/tigrbl_app.py,sha256=4WqA509WekXx1BCW7Ph2tqdFEYkzcrHCYJz8MIVjG4w,11817
+tigrbl/app/tigrbl_app.py,sha256=xM4tCdW43A-7C7-ne1okp3q2CsQynBWIgydxnZmlDlY,14836
 tigrbl/bindings/__init__.py,sha256=GcM5PTKNLS1Jx__OiAcjLI5yybL40RrA8OzMVPno4_U,2643
 tigrbl/bindings/api/__init__.py,sha256=ayw4ZBCvvUThQm9PXS6TyVkV1MEYY8YwGcyT4HwWZ7c,395
 tigrbl/bindings/api/common.py,sha256=ivTUwC35QKj0-5op_dksHx4vTsf-fWLYJjwHGuFMKcA,3599
@@ -28,17 +28,17 @@ tigrbl/bindings/handlers/namespaces.py,sha256=zA_QDEVvzX7NPQ7pN1UJwVWmjJPlxeWJYd
 tigrbl/bindings/handlers/steps.py,sha256=-Ypdjg_aFxo6vD814B6tfqZL1Dh4bG_Zmd5G6MXDDfE,9617
 tigrbl/bindings/hooks.py,sha256=tr5hI5ByfAHYQB8HClQ7RO1dg4wCFnfD0I1Jyse2AfU,12306
 tigrbl/bindings/model.py,sha256=ZgS-_NAnTJ55XyMJ9YkL2NxDFIm8LCao2XXyEO2-qoM,7553
-tigrbl/bindings/model_helpers.py,sha256=3rbt7YFT2ohBGNsd7nfKnnSnHz1nOmeE_xIyAjubBQQ,4493
+tigrbl/bindings/model_helpers.py,sha256=yI8fmHBjiHwwmnPmavZ2r0eNmCk5PpNnj1YKVKdcXvg,4513
 tigrbl/bindings/model_registry.py,sha256=ACMOIiQbyLs-89BwSNjY6iAS6xR8_vUdl0OcuT1p7ro,2424
 tigrbl/bindings/rest/__init__.py,sha256=u3vD4v9bhD8wotjt7e2Wt46pmGOC5BWHo9co9KOYLxQ,193
 tigrbl/bindings/rest/attach.py,sha256=7fGb1El6ZdCBVn3LvEcyFTNYPPeaEaIGLbyAGzM7ebE,1036
-tigrbl/bindings/rest/collection.py,sha256=GK2xD19SXkDSDeVlDiFmgsmT0zj8ssIYFFf91grfSmE,9680
+tigrbl/bindings/rest/collection.py,sha256=bRsj5bAVL7iTIgGyEhdOaHVXN_ajaP9uD4iyKvcCEFU,12675
 tigrbl/bindings/rest/common.py,sha256=K9Kpo3fxj90lcrk8lhGZp-NiInDSv4EqO8Td8VeoimU,2545
 tigrbl/bindings/rest/fastapi.py,sha256=eUg2Aj5JCBlsMSBsf0GJF9KueZnGYhUeGHQ9N7-UB6Y,2072
 tigrbl/bindings/rest/helpers.py,sha256=LrYhqokKAqgyXbxDGKIvXkW14xGoBmcSBurr9eyrPHY,3768
 tigrbl/bindings/rest/io.py,sha256=Sl1nFpAuqv9jqw835YxhdEQ43CJ2XPPA29zeUsBxDsM,11107
 tigrbl/bindings/rest/io_headers.py,sha256=ZUqhXfVlQrosnjnIFr5BP1W9fbpGdxafdYB6Dnots8g,1646
-tigrbl/bindings/rest/member.py,sha256=aSuvfBWMpGMx-rYK5Zr3Y2ATTBbBkj4IxaZyN0Yh91Q,13081
+tigrbl/bindings/rest/member.py,sha256=DKheZ14A7SGbk8BSNIV41p9Jmf4peMu6K6pOSus6sWs,13078
 tigrbl/bindings/rest/router.py,sha256=ofkC_uLot5L5wfhyr3Vclzxog-5TjAn4Gd5D5haezRM,10877
 tigrbl/bindings/rest/routing.py,sha256=5Wi3fhgLysEcaHc2dzWk1523NcRZFJpcBiMKr4aaxlo,4440
 tigrbl/bindings/rpc.py,sha256=TsRNQ2q6LH7Dn8j_fguKimUOXRKUB8gmdOek7bp8Yjo,13196
@@ -50,7 +50,7 @@ tigrbl/column/README.md,sha256=TP7kbwSg0t5ZX68iAL0_62yC2cDOmwznIM23jXb4H5E,2169
 tigrbl/column/__init__.py,sha256=84Aa9AQbmAGnJrFcH5dF92WBqFllgbZjvoPaFHijOW4,1764
 tigrbl/column/_column.py,sha256=WUDeHCglwrX0lugixzsNvTk34iUrMLPCyIcnBieA0UQ,3219
 tigrbl/column/column_spec.py,sha256=y4GLFGnpvnCbMAOJser2oKYBlN8Ifc0ILF3Rv5V47jY,1405
-tigrbl/column/field_spec.py,sha256=bXG2oioTEF3G5UyXL9MqWo_SGpHz1EJui5HfIoo0FBs,1223
+tigrbl/column/field_spec.py,sha256=vULVbaqLcM2KjsLAq-jBEo0E7b9jJzieqfrRfgDMEZE,1324
 tigrbl/column/infer/__init__.py,sha256=EBrWe1J50A-xKPE6CIN1SbJ4d27aqwjOQGyNqWOi_Ic,367
 tigrbl/column/infer/core.py,sha256=zd0tlVffsUVYynuY-J5OXQu1OLEk8M3iILhcubyls-0,2559
 tigrbl/column/infer/jsonhints.py,sha256=IBoNQJUKIIpZdwrYfsKQUA1djHC37XPm8mE-crn1qCM,1659
@@ -59,7 +59,7 @@ tigrbl/column/infer/types.py,sha256=EOyPYKQgpmwVxCapiDlxPwVvEmqsXN8AMOpoRyAzpFQ,
 tigrbl/column/infer/utils.py,sha256=J8VcLGA-KXjy3IJ2ROQ1alyfYP9qj8ukb5Z3IMvasi4,1532
 tigrbl/column/io_spec.py,sha256=GkMTkzk_2fOIo8XK_0rbYRW-Re9rCuIfPMpR4dvUyJE,4223
 tigrbl/column/mro_collect.py,sha256=jAmt-trA95xxcs5SOjwA3sxh9J_MAXDlVFSbpTcyla0,2084
-tigrbl/column/shortcuts.py,sha256=a6ns1Y5zdbgzzKeUDZq86ejV2la_HZVHmLSgWucPxKc,2606
+tigrbl/column/shortcuts.py,sha256=Cr8NlWTCpJxzdHdAo0hZNfTdMR_Tu2RWeu5s7rHZMXI,3042
 tigrbl/column/storage_spec.py,sha256=U19K6QlELQ9tTyxEA5xRWEcjCcIHcb9-iRfDwluPl_8,2396
 tigrbl/config/__init__.py,sha256=DwpSnn0f0I2dAhIMwm1u8MOrvd04syKIc96OFCk-v-o,455
 tigrbl/config/constants.py,sha256=QHFWpMfp8iqK0PZNhFDCatQZjv4kJDbHHGsPb5MqnMw,9856
@@ -143,9 +143,9 @@ tigrbl/orm/tables/status.py,sha256=Eb73GsibghSqqY_lzhsO6OxQSYvlfRTc0PnO38nDtYw,3
 tigrbl/orm/tables/tenant.py,sha256=bTNkg36A1EeRX2hQuRCUr6J78RkFdm0BgUGHNWCnOHI,450
 tigrbl/orm/tables/user.py,sha256=J0ix0hb8UgcCjoAQhSLn-XN8HR8TTt3mmlwH0bAjTJs,789
 tigrbl/response/README.md,sha256=SVfrSPT7RuZMy2JmyxL9S3bOvhGdDsZQANH-grH37FI,1758
-tigrbl/response/__init__.py,sha256=Y26CVXUlk7zvcP7oorZHxbJ5D0-KC_LcDIxQjw0QlB4,803
+tigrbl/response/__init__.py,sha256=P_N0Fr6LNywdzh0sgG9-wbU51Au5soUP2_9HdAtRE3s,884
 tigrbl/response/bind.py,sha256=fj5deXrOBn-jauvW0j2yNdVziOBvPOvbOklFQFeoyYk,293
-tigrbl/response/decorators.py,sha256=iOBBME2jSvuS_KV9zDCQKBQDNg80QLFtYboJehwqvRM,940
+tigrbl/response/decorators.py,sha256=x48FaZkjZ_xZq_v6tS9fJqVXuVvVB1wg_j95MqnejUY,1203
 tigrbl/response/resolver.py,sha256=ZCcQiBxzZuC_iteOQVcQdLBQmY8wSSJ2HYryb2YzzUA,2532
 tigrbl/response/shortcuts.py,sha256=nihXsZna0wzAH8ML9xxWyvzDM77ge2pR-JD7k8S8byM,4690
 tigrbl/response/types.py,sha256=110etKRHl0jnnhwFPCWwl6DawQ7cOel1yq4lo3r9KIk,1329
@@ -203,7 +203,7 @@ tigrbl/runtime/trace.py,sha256=67XPisJg7t5jpXghfYRdJK7hES89Jk_TQUYb2u2cDVk,9865
 tigrbl/schema/__init__.py,sha256=PM7xsbgM9L98WnVFek8_dJ_Z3V1m6JometlRLjrgu2w,967
 tigrbl/schema/_schema.py,sha256=Xf_50TOtldOa4pYM6pPBYotNqNbpq91xQJP5p8S4DwI,557
 tigrbl/schema/builder/__init__.py,sha256=9RfxmNhGIIm4zqM-iKks_J8fo6SHRBeZznHz_1lbgUk,482
-tigrbl/schema/builder/build_schema.py,sha256=2paI62EZ5_Q00Axnz67R63nSI7HRCqG-BQ5ncosVcDI,7924
+tigrbl/schema/builder/build_schema.py,sha256=rD13_mT3oQPlHZElgO4rirtxPKL8EGpyae-1rj5Dbz4,8266
 tigrbl/schema/builder/cache.py,sha256=1OwjjURIpQWRy01JCdzRUzyIUeWWCjLYtmy5XHW8wKE,521
 tigrbl/schema/builder/compat.py,sha256=KdvpV_lYWrWd9qDoGUBRrl5uXAHXMnXrF9cJW8N86pI,402
 tigrbl/schema/builder/extras.py,sha256=t-94VjVULlTDFsRDJ3IBkBUFYkwZbWajjS1JIyTExUM,2526
@@ -231,16 +231,16 @@ tigrbl/system/__init__.py,sha256=KzuvZppotGl-tcrwxKkD-mjBRHQyaeZ7AzcBTkI34cs,310
 tigrbl/system/diagnostics/__init__.py,sha256=QtQfmaE7LreWKH2Zggmh8kIAilzhF1gQYdhNOVAGuCE,717
 tigrbl/system/diagnostics/compat.py,sha256=g3rzIWKPvspdaDRlwnFzcbsmORfbo1Bjwa1VTrf0Bco,990
 tigrbl/system/diagnostics/healthz.py,sha256=hB-FX6DUJYOlQGdF-5Skb0bspO8Hi4IEOFg7AxcsrV0,1319
-tigrbl/system/diagnostics/hookz.py,sha256=by1yszQqiktf3LXb_QEEbVO6u64l_8E4bk0_Z7_mSTw,1811
+tigrbl/system/diagnostics/hookz.py,sha256=q8Fl7yPPdcEw2JkZNAEMhxKwd7EezAfdPNmAZt7E7C0,1781
 tigrbl/system/diagnostics/kernelz.py,sha256=MuM7-95yaIu28nZ3KOWYhfbYeb489Ep6ucmRTqL3JMA,433
-tigrbl/system/diagnostics/methodz.py,sha256=rZ9QpNJMxH_gH-zkSv6vK-qw3ZLRLEImP32Ki-JmyC4,1577
+tigrbl/system/diagnostics/methodz.py,sha256=kYOpKGuhPjJV5bW13-e4jHM4GQelsoc3Vf2L_s1Ado4,1628
 tigrbl/system/diagnostics/router.py,sha256=5RAv6LPoN4luGwIPnYGak66uT9FslYPc-d_GKqc4S8c,1854
 tigrbl/system/diagnostics/utils.py,sha256=qxC8pUNK2lQKh5cGlF-PSFA-cfJFLlAHW0-iEosvPgg,1172
 tigrbl/system/uvicorn.py,sha256=ogvIqfv-1CxAPZ8BADucaNAy_ePsLA3IVIZxmhdfL3A,1526
 tigrbl/table/__init__.py,sha256=yyP9iZBUJh-D7TCy9WQIvMXKL3ztyX-EXdTK4RTE7iw,207
-tigrbl/table/_base.py,sha256=2PCazG2fUuMCqTOghPsa2W7f2de-e31tX78ckfcVbHw,10456
+tigrbl/table/_base.py,sha256=k2ZEaMCygpoCMFEwOC2L02oe4cR8W3zwn2NInZcIcHI,18170
 tigrbl/table/_table.py,sha256=B7ft2SMnbp3aTWKO44M4EWTHmzFKyQlpdj-3QULRaGk,1740
-tigrbl/table/mro_collect.py,sha256=JwL0zAeLNUgJcgd2JuLKcbFc806zBguhFqpCkeZyzRw,2027
+tigrbl/table/mro_collect.py,sha256=PbuSZnUvVbs3NCe2otie7pvcjxeF54hSiVp_VywclSA,2733
 tigrbl/table/shortcuts.py,sha256=-IZAZyMTsiCdKV0w7nq1C2YBsB6iE_uNGJb-PatlO8I,1716
 tigrbl/table/table_spec.py,sha256=dvilrGWX7fVc6ThTbAqJKxxl3r6_MKNFY0cs_wuyvC8,1001
 tigrbl/transport/__init__.py,sha256=Hq2yob_mvMOQdd8Ts04-rzL282rRpIXo2Prortk0fL4,1896
@@ -250,7 +250,7 @@ tigrbl/transport/jsonrpc/helpers.py,sha256=oyqx36m8n7EofciPVvTEM9Pz1l51zJwsI224A
 tigrbl/transport/jsonrpc/models.py,sha256=omtjb-NN8HyWgIZ5tHafEsbwC7f1XlttAFHFA41Xn2k,973
 tigrbl/transport/rest/__init__.py,sha256=AU_twrP0A958FtXvLSf1i60Jn-UZSRUkAZ1Gd2TeYaw,764
 tigrbl/transport/rest/aggregator.py,sha256=V1zDvv1bwpNyt6rUPmEUEV5nORjb5sHU5LJ00m1ybYY,4454
-tigrbl/types/__init__.py,sha256=JwQCoSrk3-aPtlfd9dLXO1YAPuLc_CPUa6Uye8frFBg,4119
+tigrbl/types/__init__.py,sha256=TSmKjMPDqn_AdZEfYKuGPRkBFsT2P7fqC-BSUXRwZlA,4120
 tigrbl/types/allow_anon_provider.py,sha256=5mWvSfk_eCY_o6oMm1gSEqz6cKyJyoZ1-DcVYm0KmpA,565
 tigrbl/types/authn_abc.py,sha256=GtlXkMb59GEEXNEfeRX_ZfNzu-S4hcLsESzBAaPT2Fg,769
 tigrbl/types/nested_path_provider.py,sha256=1z-4Skz_X_hy-XGEAQnNv6vyrfFNsPIvlhBqf457Sjc,609
@@ -261,7 +261,7 @@ tigrbl/types/request_extras_provider.py,sha256=JOIpzx1PYA2AYYvkMiXrxlwpBLOPD2cQa
 tigrbl/types/response_extras_provider.py,sha256=sFB0R3vyUqmpT-o8983hH9FAlOq6-wwNVK6vfuCPHCg,653
 tigrbl/types/table_config_provider.py,sha256=EkfOhy9UDfy7EgiZddw9KIl5tRujRjXJlr4cSk1Rm5k,361
 tigrbl/types/uuid.py,sha256=pD-JrhS0L2GXeJ0Hv_oKzRuiXmxHDTVoMqExO48iqZE,1993
-tigrbl-0.3.2.dev1.dist-info/METADATA,sha256=_XdyS757AmpJyg3k2bEkaD0p5aY-_DHbCcye2UPscs8,17853
-tigrbl-0.3.2.dev1.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
-tigrbl-0.3.2.dev1.dist-info/licenses/LICENSE,sha256=djUXOlCxLVszShEpZXshZ7v33G-2qIC_j9KXpWKZSzQ,11359
-tigrbl-0.3.2.dev1.dist-info/RECORD,,
+tigrbl-0.3.3.dist-info/METADATA,sha256=jzA4dOJopmMt5CDrysJvNm2BrJDlnqLGQttYTIHp600,17848
+tigrbl-0.3.3.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+tigrbl-0.3.3.dist-info/licenses/LICENSE,sha256=djUXOlCxLVszShEpZXshZ7v33G-2qIC_j9KXpWKZSzQ,11359
+tigrbl-0.3.3.dist-info/RECORD,,