tigrbl 0.0.1.dev1__py3-none-any.whl → 0.3.0.dev3__py3-none-any.whl

tigrbl/bindings/schemas/builder.py

@@ -0,0 +1,348 @@
+from __future__ import annotations
+
+# tigrbl/v3/bindings/schemas/builder.py
+
+import logging
+from types import SimpleNamespace
+from typing import Dict, Optional, Sequence, Type
+
+from pydantic import BaseModel
+
+from ...op import OpSpec
+from ...schema import collect_decorated_schemas
+from .defaults import _default_schemas_for_spec
+from .utils import _alias_schema, _ensure_alias_namespace, _resolve_schema_arg, _Key
+
+logging.getLogger("uvicorn").setLevel(logging.DEBUG)
+logger = logging.getLogger("uvicorn")
+logger.debug("Loaded module v3/bindings/schemas/builder")
+
+
+def build_and_attach(
+    model: type, specs: Sequence[OpSpec], *, only_keys: Optional[Sequence[_Key]] = None
+) -> None:
+    """
+    Build request and response schemas per OpSpec and attach them under:
+        model.schemas.<alias>.in_   -> request model (or None)
+        model.schemas.<alias>.out   -> response model (or None)
+
+    Two-pass strategy:
+      0) Seed namespaces from @schema_ctx declarations (so SchemaRef targets exist)
+      1) Attach DEFAULT schemas for canonical ops (custom stays raw)
+      2) Apply per-spec overrides (SchemaRef / 'alias.in'|'alias.out' / 'raw' / None)
+
+    If `only_keys` is provided, overrides are limited to those (alias,target) pairs.
+    Defaults are still ensured for all specs so cross-op SchemaRefs resolve reliably
+    for canonical ops.
+    """
+    logger.debug(
+        "Building schemas for %s with %d specs (only_keys=%s)",
+        model.__name__,
+        len(specs),
+        only_keys,
+    )
+    if not hasattr(model, "schemas"):
+        model.schemas = SimpleNamespace()
+        logger.debug("Created new schemas namespace on %s", model.__name__)
+    else:
+        logger.debug("Using existing schemas namespace on %s", model.__name__)
+
+    wanted = set(only_keys or ())
+    if wanted:
+        logger.debug("Filtering overrides to keys: %s", wanted)
+
+    # Pass 0: attach schemas declared via @schema_ctx
+    declared = collect_decorated_schemas(model)  # {alias: {"in": cls, "out": cls}}
+    for alias, kinds in (declared or {}).items():
+        logger.debug("Applying declared schemas for alias '%s'", alias)
+        ns = _ensure_alias_namespace(model, alias)
+        if "in" in kinds:
+            setattr(ns, "in_", kinds["in"])
+            logger.debug("Declared request schema for %s.%s", model.__name__, alias)
+        if "out" in kinds:
+            setattr(ns, "out", kinds["out"])
+            logger.debug("Declared response schema for %s.%s", model.__name__, alias)
+
+    # Ensure a namespace per op alias (even if empty)
+    for sp in specs:
+        _ = _ensure_alias_namespace(model, sp.alias)
+        logger.debug("Ensured namespace for alias '%s'", sp.alias)
+
+    # Pass 1: attach defaults for all specs and capture them so canonical
+    # defaults can be restored later if needed.
+    # Existing schemas that lack fields are treated as missing so they are
+    # replaced with freshly built defaults.  This protects against earlier
+    # auto-binding passes that may have produced placeholder models.
+    defaults: Dict[_Key, Dict[str, Optional[Type[BaseModel]]]] = {}
+    for sp in specs:
+        ns = _ensure_alias_namespace(model, sp.alias)
+        shapes = _default_schemas_for_spec(model, sp)
+        defaults[(sp.alias, sp.target)] = shapes
+
+        if shapes.get("in_") is not None:
+            existing_in = getattr(ns, "in_", None)
+            if existing_in is None or not getattr(existing_in, "model_fields", None):
+                setattr(ns, "in_", shapes["in_"])
+                logger.debug(
+                    "Attached default request schema for %s.%s",
+                    model.__name__,
+                    sp.alias,
+                )
+            else:
+                logger.debug(
+                    "Keeping existing request schema for %s.%s",
+                    model.__name__,
+                    sp.alias,
+                )
+        else:
+            logger.debug(
+                "No default request schema for %s.%s", model.__name__, sp.alias
+            )
+
+        if shapes.get("in_item") is not None:
+            existing_in_item = getattr(ns, "in_item", None)
+            if existing_in_item is None or not getattr(
+                existing_in_item, "model_fields", None
+            ):
+                setattr(ns, "in_item", shapes["in_item"])
+                logger.debug(
+                    "Attached default request item schema for %s.%s",
+                    model.__name__,
+                    sp.alias,
+                )
+            else:
+                logger.debug(
+                    "Keeping existing request item schema for %s.%s",
+                    model.__name__,
+                    sp.alias,
+                )
+        else:
+            logger.debug(
+                "No default request item schema for %s.%s", model.__name__, sp.alias
+            )
+
+        if shapes.get("out") is not None:
+            existing_out = getattr(ns, "out", None)
+            if existing_out is None or not getattr(existing_out, "model_fields", None):
+                setattr(ns, "out", shapes["out"])
+                logger.debug(
+                    "Attached default response schema for %s.%s",
+                    model.__name__,
+                    sp.alias,
+                )
+            else:
+                logger.debug(
+                    "Keeping existing response schema for %s.%s",
+                    model.__name__,
+                    sp.alias,
+                )
+        else:
+            logger.debug(
+                "No default response schema for %s.%s", model.__name__, sp.alias
+            )
+
+        if shapes.get("out_item") is not None:
+            existing_out_item = getattr(ns, "out_item", None)
+            if existing_out_item is None or not getattr(
+                existing_out_item, "model_fields", None
+            ):
+                setattr(ns, "out_item", shapes["out_item"])
+                logger.debug(
+                    "Attached default response item schema for %s.%s",
+                    model.__name__,
+                    sp.alias,
+                )
+            else:
+                logger.debug(
+                    "Keeping existing response item schema for %s.%s",
+                    model.__name__,
+                    sp.alias,
+                )
+        else:
+            logger.debug(
+                "No default response item schema for %s.%s", model.__name__, sp.alias
+            )
+
+        logger.debug(
+            "schemas(default): %s.%s -> in=%s out=%s",
+            model.__name__,
+            sp.alias,
+            getattr(ns, "in_", None).__name__ if getattr(ns, "in_", None) else None,
+            getattr(ns, "out", None).__name__ if getattr(ns, "out", None) else None,
+        )
+
+    # Pass 2: apply per-spec overrides (respect only_keys if provided)
+    for sp in specs:
+        key = (sp.alias, sp.target)
+        if wanted and key not in wanted:
+            logger.debug(
+                "Skipping overrides for %s.%s not in only_keys",
+                model.__name__,
+                sp.alias,
+            )
+            continue
+
+        ns = _ensure_alias_namespace(model, sp.alias)
+
+        if sp.request_model is not None:
+            logger.debug(
+                "Resolving request override for %s.%s", model.__name__, sp.alias
+            )
+            try:
+                resolved_in = _resolve_schema_arg(
+                    model, sp.request_model
+                )  # Optional[Type[BaseModel]]
+            except Exception as e:
+                logger.exception(
+                    "Failed resolving request schema for %s.%s: %s",
+                    model.__name__,
+                    sp.alias,
+                    e,
+                )
+                raise
+            setattr(ns, "in_", resolved_in)
+            logger.debug(
+                "Request override for %s.%s resolved to %s",
+                model.__name__,
+                sp.alias,
+                getattr(resolved_in, "__name__", None),
+            )
+        else:
+            logger.debug("No request override for %s.%s", model.__name__, sp.alias)
+
+        if sp.response_model is not None:
+            logger.debug(
+                "Resolving response override for %s.%s", model.__name__, sp.alias
+            )
+            try:
+                resolved_out = _resolve_schema_arg(
+                    model, sp.response_model
+                )  # Optional[Type[BaseModel]]
+            except Exception as e:
+                logger.exception(
+                    "Failed resolving response schema for %s.%s: %s",
+                    model.__name__,
+                    sp.alias,
+                    e,
+                )
+                raise
+            setattr(ns, "out", resolved_out)
+            logger.debug(
+                "Response override for %s.%s resolved to %s",
+                model.__name__,
+                sp.alias,
+                getattr(resolved_out, "__name__", None),
+            )
+        else:
+            logger.debug("No response override for %s.%s", model.__name__, sp.alias)
+
+        logger.debug(
+            "schemas(override): %s.%s -> in=%s out=%s",
+            model.__name__,
+            sp.alias,
+            getattr(ns, "in_", None).__name__ if getattr(ns, "in_", None) else None,
+            getattr(ns, "out", None).__name__ if getattr(ns, "out", None) else None,
+        )
+
+    # Pass 2b: restore canonical defaults if overrides cleared them
+    for sp in specs:
+        if sp.target == "custom":
+            logger.debug(
+                "Skipping default restoration for custom target %s.%s",
+                model.__name__,
+                sp.alias,
+            )
+            continue
+        ns = _ensure_alias_namespace(model, sp.alias)
+        shapes = defaults.get((sp.alias, sp.target)) or {}
+        if getattr(ns, "in_", None) is None and shapes.get("in_") is not None:
+            setattr(ns, "in_", shapes["in_"])
+            logger.debug(
+                "Restored default request schema for %s.%s", model.__name__, sp.alias
+            )
+        else:
+            logger.debug(
+                "No request schema restoration needed for %s.%s",
+                model.__name__,
+                sp.alias,
+            )
+        if getattr(ns, "in_item", None) is None and shapes.get("in_item") is not None:
+            setattr(ns, "in_item", shapes["in_item"])
+            logger.debug(
+                "Restored default request item schema for %s.%s",
+                model.__name__,
+                sp.alias,
+            )
+        else:
+            logger.debug(
+                "No request item schema restoration needed for %s.%s",
+                model.__name__,
+                sp.alias,
+            )
+        if getattr(ns, "out", None) is None and shapes.get("out") is not None:
+            setattr(ns, "out", shapes["out"])
+            logger.debug(
+                "Restored default response schema for %s.%s", model.__name__, sp.alias
+            )
+        else:
+            logger.debug(
+                "No response schema restoration needed for %s.%s",
+                model.__name__,
+                sp.alias,
+            )
+        if getattr(ns, "out_item", None) is None and shapes.get("out_item") is not None:
+            setattr(ns, "out_item", shapes["out_item"])
+            logger.debug(
+                "Restored default response item schema for %s.%s",
+                model.__name__,
+                sp.alias,
+            )
+        else:
+            logger.debug(
+                "No response item schema restoration needed for %s.%s",
+                model.__name__,
+                sp.alias,
+            )
+
+    # Pass 3: ensure alias-specific request/response schema names
+    for sp in specs:
+        ns = _ensure_alias_namespace(model, sp.alias)
+        in_model = getattr(ns, "in_", None)
+        if (
+            isinstance(in_model, type)
+            and issubclass(in_model, BaseModel)
+            and getattr(in_model, "__tigrbl_schema_decl__", None) is None
+        ):
+            logger.debug("Aliasing request schema for %s.%s", model.__name__, sp.alias)
+            setattr(
+                ns,
+                "in_",
+                _alias_schema(in_model, model=model, alias=sp.alias, kind="Request"),
+            )
+        else:
+            logger.debug(
+                "Request schema for %s.%s already aliased or missing",
+                model.__name__,
+                sp.alias,
+            )
+        out_model = getattr(ns, "out", None)
+        if (
+            isinstance(out_model, type)
+            and issubclass(out_model, BaseModel)
+            and getattr(out_model, "__tigrbl_schema_decl__", None) is None
+        ):
+            logger.debug("Aliasing response schema for %s.%s", model.__name__, sp.alias)
+            setattr(
+                ns,
+                "out",
+                _alias_schema(out_model, model=model, alias=sp.alias, kind="Response"),
+            )
+        else:
+            logger.debug(
+                "Response schema for %s.%s already aliased or missing",
+                model.__name__,
+                sp.alias,
+            )
+
+
+__all__ = ["build_and_attach"]

tigrbl/bindings/schemas/defaults.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+import logging
+
+# tigrbl/v3/bindings/schemas/defaults.py
+
+from typing import Dict, Optional, Type
+
+from pydantic import BaseModel
+
+from ...op import OpSpec
+from ...schema import (
+    _build_schema,
+    _build_list_params,
+    _make_bulk_rows_model,
+    _make_bulk_rows_response_model,
+    _make_bulk_ids_model,
+    _make_deleted_response_model,
+    _make_pk_model,
+)
+from .utils import _pk_info
+
+logging.getLogger("uvicorn").setLevel(logging.DEBUG)
+logger = logging.getLogger("uvicorn")
+logger.debug("Loaded module v3/bindings/schemas/defaults")
+
+
+def _default_schemas_for_spec(
+    model: type, sp: OpSpec
+) -> Dict[str, Optional[Type[BaseModel]]]:
+    """
+    Decide default IN/OUT schemas for a given OpSpec (ignores sp.request_model/response_model).
+
+    New rules:
+      • Canonical targets → provide canonical defaults.
+      • Custom target     → no defaults (raw) unless explicitly overridden.
+    """
+    target = sp.target
+    result: Dict[str, Optional[Type[BaseModel]]] = {
+        "in_": None,
+        "out": None,
+        "in_item": None,
+        "out_item": None,
+    }
+
+    # Element schema for many OUT shapes
+    read_schema: Optional[Type[BaseModel]] = _build_schema(model, verb="read")
+    logger.debug(
+        "Resolved base read schema for %s as %s",
+        model.__name__,
+        read_schema.__name__ if read_schema else None,
+    )
+
+    # Canonical targets
+    logger.debug(
+        "Building default schemas for %s.%s (target=%s)",
+        model.__name__,
+        sp.alias,
+        target,
+    )
+    if target == "create":
+        logger.debug("Using create defaults for %s.%s", model.__name__, sp.alias)
+        item_in = _build_schema(model, verb="create")
+        result["in_"] = item_in
+        result["out"] = read_schema
+
+    elif target == "read":
+        logger.debug("Using read defaults for %s.%s", model.__name__, sp.alias)
+        pk_name, pk_type = _pk_info(model)
+        result["in_"] = _make_pk_model(model, "read", pk_name, pk_type)
+        result["out"] = read_schema
+
+    elif target == "update":
+        logger.debug("Using update defaults for %s.%s", model.__name__, sp.alias)
+        pk_name, _ = _pk_info(model)
+        result["in_"] = _build_schema(model, verb="update", exclude={pk_name})
+        result["out"] = read_schema
+
+    elif target == "replace":
+        logger.debug("Using replace defaults for %s.%s", model.__name__, sp.alias)
+        pk_name, _ = _pk_info(model)
+        result["in_"] = _build_schema(model, verb="replace", exclude={pk_name})
+        result["out"] = read_schema
+
+    elif target == "merge":
+        logger.debug("Using merge defaults for %s.%s", model.__name__, sp.alias)
+        pk_name, _ = _pk_info(model)
+        result["in_"] = _build_schema(model, verb="update", exclude={pk_name})
+        result["out"] = read_schema
+
+    elif target == "delete":
+        logger.debug("Using delete defaults for %s.%s", model.__name__, sp.alias)
+        # For RPC delete, a body with PK is allowed; REST delete ignores body.
+        result["in_"] = _build_schema(model, verb="delete")
+        result["out"] = read_schema
+
+    elif target == "list":
+        logger.debug("Using list defaults for %s.%s", model.__name__, sp.alias)
+        params = _build_list_params(model)
+        result["in_"] = params
+        result["out"] = read_schema
+
+    elif target == "clear":
+        logger.debug("Using clear defaults for %s.%s", model.__name__, sp.alias)
+        params = _build_list_params(model)
+        result["in_"] = params
+        result["out"] = _make_deleted_response_model(model, "clear")
+
+    elif target == "bulk_create":
+        logger.debug("Using bulk_create defaults for %s.%s", model.__name__, sp.alias)
+        item_in = _build_schema(
+            model,
+            verb="create",
+            name=f"{model.__name__}BulkCreateItem",
+        )
+        result["in_"] = _make_bulk_rows_model(model, "bulk_create", item_in)
+        result["in_item"] = item_in
+        if read_schema:
+            result["out"] = _make_bulk_rows_response_model(
+                model, "bulk_create", read_schema
+            )
+            result["out_item"] = read_schema
+            logger.debug(
+                "Built bulk_create response schemas for %s.%s", model.__name__, sp.alias
+            )
+        else:
+            result["out"] = None
+            result["out_item"] = None
+            logger.debug(
+                "No read schema available for bulk_create %s.%s",
+                model.__name__,
+                sp.alias,
+            )
+
+    elif target == "bulk_update":
+        logger.debug("Using bulk_update defaults for %s.%s", model.__name__, sp.alias)
+        item_in = _build_schema(
+            model,
+            verb="update",
+            name=f"{model.__name__}BulkUpdateItem",
+        )
+        result["in_"] = _make_bulk_rows_model(model, "bulk_update", item_in)
+        result["in_item"] = item_in
+        if read_schema:
+            result["out"] = _make_bulk_rows_response_model(
+                model, "bulk_update", read_schema
+            )
+            result["out_item"] = read_schema
+            logger.debug(
+                "Built bulk_update response schemas for %s.%s", model.__name__, sp.alias
+            )
+        else:
+            result["out"] = None
+            result["out_item"] = None
+            logger.debug(
+                "No read schema available for bulk_update %s.%s",
+                model.__name__,
+                sp.alias,
+            )
+
+    elif target == "bulk_replace":
+        logger.debug("Using bulk_replace defaults for %s.%s", model.__name__, sp.alias)
+        item_in = _build_schema(
+            model,
+            verb="replace",
+            name=f"{model.__name__}BulkReplaceItem",
+        )
+        result["in_"] = _make_bulk_rows_model(model, "bulk_replace", item_in)
+        result["in_item"] = item_in
+        if read_schema:
+            result["out"] = _make_bulk_rows_response_model(
+                model, "bulk_replace", read_schema
+            )
+            result["out_item"] = read_schema
+            logger.debug(
+                "Built bulk_replace response schemas for %s.%s",
+                model.__name__,
+                sp.alias,
+            )
+        else:
+            result["out"] = None
+            result["out_item"] = None
+            logger.debug(
+                "No read schema available for bulk_replace %s.%s",
+                model.__name__,
+                sp.alias,
+            )
+
+    elif target == "bulk_merge":
+        logger.debug("Using bulk_merge defaults for %s.%s", model.__name__, sp.alias)
+        item_in = _build_schema(
+            model,
+            verb="update",
+            name=f"{model.__name__}BulkMergeItem",
+        )
+        result["in_"] = _make_bulk_rows_model(model, "bulk_merge", item_in)
+        result["in_item"] = item_in
+        if read_schema:
+            result["out"] = _make_bulk_rows_response_model(
+                model, "bulk_merge", read_schema
+            )
+            result["out_item"] = read_schema
+            logger.debug(
+                "Built bulk_merge response schemas for %s.%s", model.__name__, sp.alias
+            )
+        else:
+            result["out"] = None
+            result["out_item"] = None
+            logger.debug(
+                "No read schema available for bulk_merge %s.%s",
+                model.__name__,
+                sp.alias,
+            )
+
+    elif target == "bulk_delete":
+        logger.debug("Using bulk_delete defaults for %s.%s", model.__name__, sp.alias)
+        pk_name, pk_type = _pk_info(model)
+        result["in_"] = _make_bulk_ids_model(model, "bulk_delete", pk_type)
+        result["out"] = _make_deleted_response_model(model, "bulk_delete")
+
+    elif target == "custom":
+        logger.debug("Using custom defaults for %s.%s", model.__name__, sp.alias)
+        # Build schemas for custom operations based on verb-specific IO specs
+        alias = sp.alias
+        specs = getattr(model, "__tigrbl_cols__", {})
+        in_fields = {
+            name
+            for name, spec in specs.items()
+            if alias in set(getattr(getattr(spec, "io", None), "in_verbs", []) or [])
+        }
+        out_fields = {
+            name
+            for name, spec in specs.items()
+            if alias in set(getattr(getattr(spec, "io", None), "out_verbs", []) or [])
+        }
+        result["in_"] = (
+            _build_schema(model, verb=alias, include=in_fields) if in_fields else None
+        )
+        result["out"] = (
+            _build_schema(model, verb=alias, include=out_fields) if out_fields else None
+        )
+
+    else:
+        logger.debug(
+            "Target '%s' unknown for %s.%s, leaving schemas raw",
+            target,
+            model.__name__,
+            sp.alias,
+        )
+        # Defensive default: treat unknown like custom (raw)
+        result["in_"] = None
+        result["out"] = None
+
+    logger.debug(
+        "Built default schemas for %s.%s -> in=%s out=%s",
+        model.__name__,
+        sp.alias,
+        result["in_"].__name__ if result["in_"] else None,
+        result["out"].__name__ if result["out"] else None,
+    )
+    return result