tigrbl 0.3.2.dev1__tar.gz → 0.3.3__tar.gz

{tigrbl-0.3.2.dev1 → tigrbl-0.3.3}/PKG-INFO

@@ -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 → tigrbl-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tigrbl"
-version = "0.3.2.dev1"
+version = "0.3.3"
 description = "Automatic API generation tools by Swarmauri."
 license = "Apache-2.0"
 readme = "README.md"

{tigrbl-0.3.2.dev1 → tigrbl-0.3.3}/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-0.3.2.dev1 → tigrbl-0.3.3}/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-0.3.2.dev1 → tigrbl-0.3.3}/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-0.3.3/tigrbl/app/mro_collect.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import logging
+from functools import lru_cache
+from typing import Any, Tuple
+
+from .app_spec import AppSpec
+
+logger = logging.getLogger("uvicorn")
+
+
+def _merge_seq_attr(
+    app: type,
+    attr: str,
+    *,
+    include_inherited: bool = False,
+    reverse: bool = False,
+) -> Tuple[Any, ...]:
+    values: list[Any] = []
+    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
+            values.append(seq)
+    return tuple(values)
+
+
+@lru_cache(maxsize=None)
+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__)
+
+    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 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",
+            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"),
+        hooks=_merge_seq_attr(app, "HOOKS"),
+        security_deps=_merge_seq_attr(app, "SECURITY_DEPS"),
+        deps=_merge_seq_attr(app, "DEPS"),
+        response=response,
+        jsonrpc_prefix=jsonrpc_prefix,
+        system_prefix=system_prefix,
+        middlewares=_merge_seq_attr(app, "MIDDLEWARES"),
+        lifespan=lifespan,
+    )
+    return spec
+
+
+__all__ = ["mro_collect_app_spec"]

{tigrbl-0.3.2.dev1 → tigrbl-0.3.3}/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-0.3.2.dev1 → tigrbl-0.3.3}/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-0.3.2.dev1 → tigrbl-0.3.3}/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-0.3.2.dev1 → tigrbl-0.3.3}/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-0.3.2.dev1 → tigrbl-0.3.3}/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-0.3.2.dev1 → tigrbl-0.3.3}/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-0.3.2.dev1 → tigrbl-0.3.3}/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-0.3.2.dev1 → tigrbl-0.3.3}/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-0.3.2.dev1 → tigrbl-0.3.3}/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-0.3.2.dev1 → tigrbl-0.3.3}/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