tigrbl-runtime 0.4.4.dev1__tar.gz → 0.4.4.dev7__tar.gz

{tigrbl_runtime-0.4.4.dev1 → tigrbl_runtime-0.4.4.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl-runtime
-Version: 0.4.4.dev1
+Version: 0.4.4.dev7
 Summary: Runtime pipeline helpers and execution bridge surfaces for Tigrbl ASGI applications, transports, and operation dispatch.
 License: Apache License
                                     Version 2.0, January 2004
@@ -311,8 +311,7 @@ pip install tigrbl-runtime
 `tigrbl-runtime` owns the `foundational framework package` boundary. It should be installed when you need this package's focused responsibility without assuming every other Tigrbl workspace package is present.
 
 Implementation orientation:
-- `tigrbl_runtime`: callbacks, channel/, config/, executors/, handle, protocol/, runtime/, transactions, webhooks
-- `tigrbl_runtime/rust/`: deprecated compatibility shims only; Rust execution is unavailable.
+- `tigrbl_runtime`: callbacks, channel/, config/, executors/, protocol/, runtime/, transactions, webhooks
 
 Runtime authoring BCP:
 - Do use this package for runtime-owned routing, request execution, transport-unit execution, framing atoms, transport channels, transaction helpers, and kernel integration.
@@ -325,7 +324,6 @@ Runtime authoring BCP:
 
 - Import roots: `tigrbl_runtime`.
 - Public symbols: `Runtime`, `RuntimeBase`.
-- Rust-named symbols live only under `tigrbl_runtime.rust` as deprecated compatibility shims and must not be used for execution.
 - Workspace dependencies: [`tigrbl-typing`](https://pypi.org/project/tigrbl-typing/), [`tigrbl-kernel`](https://pypi.org/project/tigrbl-kernel/), [`tigrbl-atoms`](https://pypi.org/project/tigrbl-atoms/), [`tigrbl-base`](https://pypi.org/project/tigrbl-base/), [`tigrbl-core`](https://pypi.org/project/tigrbl-core/).
 - External runtime dependencies: `numba>=0.61.2`.
 

{tigrbl_runtime-0.4.4.dev1 → tigrbl_runtime-0.4.4.dev7}/README.md

@@ -71,8 +71,7 @@ pip install tigrbl-runtime
 `tigrbl-runtime` owns the `foundational framework package` boundary. It should be installed when you need this package's focused responsibility without assuming every other Tigrbl workspace package is present.
 
 Implementation orientation:
-- `tigrbl_runtime`: callbacks, channel/, config/, executors/, handle, protocol/, runtime/, transactions, webhooks
-- `tigrbl_runtime/rust/`: deprecated compatibility shims only; Rust execution is unavailable.
+- `tigrbl_runtime`: callbacks, channel/, config/, executors/, protocol/, runtime/, transactions, webhooks
 
 Runtime authoring BCP:
 - Do use this package for runtime-owned routing, request execution, transport-unit execution, framing atoms, transport channels, transaction helpers, and kernel integration.
@@ -85,7 +84,6 @@ Runtime authoring BCP:
 
 - Import roots: `tigrbl_runtime`.
 - Public symbols: `Runtime`, `RuntimeBase`.
-- Rust-named symbols live only under `tigrbl_runtime.rust` as deprecated compatibility shims and must not be used for execution.
 - Workspace dependencies: [`tigrbl-typing`](https://pypi.org/project/tigrbl-typing/), [`tigrbl-kernel`](https://pypi.org/project/tigrbl-kernel/), [`tigrbl-atoms`](https://pypi.org/project/tigrbl-atoms/), [`tigrbl-base`](https://pypi.org/project/tigrbl-base/), [`tigrbl-core`](https://pypi.org/project/tigrbl-core/).
 - External runtime dependencies: `numba>=0.61.2`.
 

{tigrbl_runtime-0.4.4.dev1 → tigrbl_runtime-0.4.4.dev7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tigrbl-runtime"
-version = "0.4.4.dev1"
+version = "0.4.4.dev7"
 description = "Runtime pipeline helpers and execution bridge surfaces for Tigrbl ASGI applications, transports, and operation dispatch."
 readme = "README.md"
 license = { file = "LICENSE" }

{tigrbl_runtime-0.4.4.dev1 → tigrbl_runtime-0.4.4.dev7}/tigrbl_runtime/channel/_asgi_webtransport.py

@@ -114,8 +114,11 @@ def _iter_webtransport_hooks(ctx: Any) -> tuple[HookSpec, ...]:
     hooks: list[HookSpec] = []
     seen: set[int] = set()
     for owner_key in ("app", "router"):
-        owner = ctx.get(owner_key) if isinstance(ctx, dict) else None
-        for item in tuple(getattr(owner, "hooks", ()) or ()):
+        getter = getattr(ctx, "get", None)
+        owner = getter(owner_key) if callable(getter) else None
+        if owner is None:
+            owner = getattr(ctx, owner_key, None)
+        for item in _iter_hook_candidates(getattr(owner, "hooks", ())):
             if id(item) in seen:
                 continue
             if isinstance(item, HookSpec):
@@ -128,6 +131,19 @@ def _iter_webtransport_hooks(ctx: Any) -> tuple[HookSpec, ...]:
     return tuple(sorted(hooks, key=lambda hook: int(getattr(hook, "order", 0))))
 
 
+def _iter_hook_candidates(value: Any) -> tuple[Any, ...]:
+    if value is None:
+        return ()
+    if isinstance(value, Mapping):
+        return tuple(value.values())
+    if isinstance(value, (list, tuple, set, frozenset)):
+        return tuple(value)
+    data = getattr(value, "__dict__", None)
+    if isinstance(data, Mapping):
+        return tuple(data.values())
+    return ()
+
+
 async def _call_webtransport_hook(hook: HookSpec, ctx: Any) -> None:
     fn = hook.fn
     try:

{tigrbl_runtime-0.4.4.dev1 → tigrbl_runtime-0.4.4.dev7}/tigrbl_runtime/executors/__init__.py

@@ -11,9 +11,7 @@ _EXPORTS = {
     "PackedPlanExecutor": "packed",
     "NumbaPackedPlanExecutor": "numba_packed",
     "_Ctx": "types",
-    "_invoke": "invoke",
-    "resolve_phase_chains": "invoke",
-    "invoke_op": "invoke",
+    "_invoke": "phase_runner",
 }
 
 __all__ = list(_EXPORTS)

{tigrbl_runtime-0.4.4.dev1 → tigrbl_runtime-0.4.4.dev7}/tigrbl_runtime/executors/_invoke_support.py

@@ -4,17 +4,13 @@ import logging
 from typing import Any, Mapping, Optional, Union
 
 from tigrbl_kernel.helpers import _g, _run_chain
-from tigrbl_ops_oltp.crud import ops as _crud_ops
-from tigrbl_ops_oltp.crud.helpers.model import _coerce_pk_value, _single_pk_name
 
 from .types import AsyncSession, PhaseChains, Session, _Ctx
 
 logger = logging.getLogger(__name__)
 
-_OPVIEW_CACHE_ATTR = "__tigrbl_cached_opviews__"
 _LOG_NOISE_REDUCED = False
 _NOISY_TIGRBL_LOGGERS = (
-    "tigrbl_ops_oltp.crud.helpers.model",
     "tigrbl_core._spec.column_spec",
 )
 
@@ -112,54 +108,6 @@ async def _maybe_await(value: Any) -> Any:
     return value
 
 
-async def _crud_result_fallback(ctx: _Ctx, current_result: Any) -> Any:
-    alias = str(ctx.get("op") or "").lower()
-    if alias not in {"read", "update", "replace"}:
-        return current_result
-
-    model = ctx.get("model")
-    db = ctx.get("db")
-    if not isinstance(model, type) or db is None:
-        return current_result
-
-    try:
-        pk_name = _single_pk_name(model)
-    except Exception:
-        return current_result
-
-    payload = ctx.get("payload")
-    path_params = ctx.get("path_params")
-    ident = None
-    if isinstance(path_params, Mapping) and pk_name in path_params:
-        ident = path_params.get(pk_name)
-    elif isinstance(payload, Mapping) and pk_name in payload:
-        ident = payload.get(pk_name)
-    if ident is None:
-        return current_result
-
-    ident = _coerce_pk_value(model, ident)
-
-    if alias == "read":
-        needs_fallback = current_result is None
-        if isinstance(current_result, Mapping):
-            if pk_name not in current_result:
-                needs_fallback = True
-            else:
-                data_keys = [k for k in current_result.keys() if k != pk_name]
-                if data_keys and all(current_result.get(k) is None for k in data_keys):
-                    needs_fallback = True
-        if not needs_fallback:
-            return current_result
-        return await _crud_ops.read(model, ident, db)
-
-    if current_result is None and isinstance(payload, Mapping):
-        if alias == "update":
-            return await _crud_ops.update(model, ident, dict(payload), db)
-        return await _crud_ops.replace(model, ident, dict(payload), db)
-
-    return current_result
-
-
 async def _rollback_if_owned(
     db: Union[Session, AsyncSession, None],
     owns_tx: bool,
@@ -181,8 +129,6 @@ async def _rollback_if_owned(
 
 
 __all__ = [
-    "_OPVIEW_CACHE_ATTR",
-    "_crud_result_fallback",
     "_default_status_for_alias",
     "_maybe_await",
     "_normalize_result_payload",

tigrbl_runtime-0.4.4.dev7/tigrbl_runtime/executors/kernel_executor.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, MutableMapping
+from types import SimpleNamespace
+from typing import Any
+
+from .phase_runner import _invoke
+from .types import _Ctx
+from tigrbl_typing.phases import canonicalize_phase_input as normalize_phase
+
+
+async def _run(
+    self,
+    model: type,
+    alias: str,
+    *,
+    db: Any,
+    request: Any | None = None,
+    ctx: Any | None = None,
+) -> Any:
+    phases = self._build_op(model, alias)
+    base_ctx = _Ctx.ensure(request=request, db=db, seed=ctx)
+    return await _invoke(request=request, db=db, phases=phases, ctx=base_ctx)
+
+
+async def _run_phase_chain(self, ctx: _Ctx, phases: Any) -> None:
+    for _phase, steps in (phases or {}).items():
+        ctx.phase = normalize_phase(_phase)
+        for step in steps or ():
+            rv = step(ctx)
+            if hasattr(rv, "__await__"):
+                await rv
+
+
+def resolve_phase_chains(model: type, alias: str) -> Mapping[str, list[Any]]:
+    """Resolve executable phase chains for a model operation."""
+    from tigrbl_kernel import build_phase_chains
+
+    return build_phase_chains(model, alias) or {}
+
+
+async def invoke_op(
+    *,
+    request: Any = None,
+    db: Any = None,
+    model: type,
+    alias: str,
+    ctx: MutableMapping[str, Any] | None = None,
+) -> Any:
+    """Resolve operation metadata and execute its phase lifecycle."""
+    from tigrbl_kernel import _default_kernel, get_cached_specs
+
+    seed_ctx: MutableMapping[str, Any] = dict(ctx or {})
+    seed_ctx.setdefault("model", model)
+    seed_ctx.setdefault("op", alias)
+    seed_ctx.setdefault("method", alias)
+    if request is not None:
+        seed_ctx.setdefault("request", request)
+    if db is not None:
+        seed_ctx.setdefault("db", db)
+    if seed_ctx.get("env") is None:
+        seed_ctx["env"] = SimpleNamespace(method=alias)
+    seed_ctx.setdefault("skip_egress", True)
+
+    app_ref = (
+        getattr(request, "app", None)
+        or seed_ctx.get("app")
+        or seed_ctx.get("router")
+        or model
+    )
+    seed_ctx.setdefault("app", app_ref)
+    seed_ctx.setdefault("router", seed_ctx.get("router") or app_ref)
+
+    if seed_ctx.get("specs") is None:
+        specs = get_cached_specs(model)
+        if specs is not None:
+            seed_ctx["specs"] = specs
+
+    if seed_ctx.get("opview") is None:
+        try:
+            seed_ctx["opview"] = _default_kernel.get_opview(app_ref, model, alias)
+        except Exception:
+            # Some call paths rely only on specs/schemas and can proceed without
+            # a compiled opview.
+            pass
+
+    return await _invoke(
+        request=request,
+        db=db,
+        phases=resolve_phase_chains(model, alias),
+        ctx=seed_ctx,
+    )

{tigrbl_runtime-0.4.4.dev1 → tigrbl_runtime-0.4.4.dev7}/tigrbl_runtime/executors/packed.py

@@ -1431,6 +1431,33 @@ class PackedPlanExecutor(ExecutorBase):
         hot.absent_fields = tuple(absent)
         hot.used_default_factory = tuple(used_default)
 
+    @staticmethod
+    def _publish_compiled_payload(ctx: _Ctx, hot: HotCtx) -> None:
+        field_names = tuple(getattr(hot, "slot_field_names", ()) or ())
+        values = getattr(hot, "assembled_slot_values", None)
+        present = getattr(hot, "assembled_slot_present", None)
+        if not field_names or values is None or present is None:
+            return
+        payload = {
+            field_names[idx]: values[idx]
+            for idx in range(min(len(field_names), len(values), len(present)))
+            if present[idx]
+        }
+        if not payload:
+            return
+        ctx["payload"] = payload
+        ctx["in_data"] = payload
+        ctx["data"] = payload
+
+    @staticmethod
+    def _publish_route_payload(ctx: _Ctx, hot: HotCtx) -> None:
+        payload = getattr(hot, "route_payload", None)
+        if not isinstance(payload, Mapping):
+            return
+        ctx["payload"] = dict(payload)
+        ctx["in_data"] = dict(payload)
+        ctx["data"] = dict(payload)
+
     def _resolve_segments_for_program(
         self, packed: PackedKernel, program_id: int
     ) -> tuple[tuple[int, ...], tuple[int, ...]]:
@@ -2699,6 +2726,7 @@ class PackedPlanExecutor(ExecutorBase):
             if hot is None:
                 return
             await self._prepare_compiled_input(ctx, hot, packed, program_id, hot_op_plan)
+            self._publish_route_payload(ctx, hot)
             if hot.compiled_input_ready:
                 plan = self._resolve_compiled_param_plan(
                     ctx,
@@ -2707,6 +2735,7 @@ class PackedPlanExecutor(ExecutorBase):
                     hot.param_shape_id,
                 )
                 self._compiled_validate_and_assemble(ctx, hot, plan)
+                self._publish_compiled_payload(ctx, hot)
             current_phase = ""
             for phase_name, invoke_kind, call, dep, is_async in compiled_steps:
                 if phase_name != current_phase:

{tigrbl_runtime-0.4.4.dev1 → tigrbl_runtime-0.4.4.dev7}/tigrbl_runtime/executors/phase.py

@@ -6,7 +6,7 @@ from tigrbl_kernel.models import KernelPlan
 
 from .base import ExecutorBase
 from .types import _Ctx
-from .invoke import _invoke
+from .phase_runner import _invoke
 
 
 class PhaseExecutor(ExecutorBase):

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/executors/invoke.py → tigrbl_runtime-0.4.4.dev7/tigrbl_runtime/executors/phase_runner.py

@@ -1,4 +1,3 @@
-# tigrbl/runtime/executor/invoke.py
 from __future__ import annotations
 
 from types import SimpleNamespace
@@ -6,14 +5,11 @@ from typing import Any, Mapping, MutableMapping, Optional, Union
 
 from tigrbl_atoms.atoms.sys._db import _in_transaction
 from tigrbl_atoms.types import build_error_ctx, error_phase_for, select_error_edge
-from tigrbl_kernel import build_phase_chains, get_cached_specs, _default_kernel
 from tigrbl_kernel.helpers import _g, _run_chain
 from tigrbl_typing.status import create_standardized_error, to_rpc_error_payload
 
 from ..config.constants import CTX_SKIP_PERSIST_FLAG
 from ._invoke_support import (
-    _OPVIEW_CACHE_ATTR as _OPVIEW_CACHE_ATTR,
-    _crud_result_fallback as _crud_result_fallback,
     _default_status_for_alias as _default_status_for_alias,
     _maybe_await as _maybe_await,
     _normalize_result_payload as _normalize_result_payload,
@@ -25,11 +21,6 @@ from ._invoke_support import (
 from .types import AsyncSession, PhaseChains, Request, Session, _Ctx
 
 
-def resolve_phase_chains(model: type, alias: str) -> Mapping[str, list[Any]]:
-    """Resolve executable phase chains for a model operation."""
-    return build_phase_chains(model, alias) or {}
-
-
 async def _invoke(
     *,
     request: Optional[Request],
@@ -59,46 +50,10 @@ async def _invoke(
         obj = getattr(ctx, "obj", None)
         if obj is not None:
             ctx.model = type(obj)
-    if getattr(ctx, "opview", None) is None:
-        model = getattr(ctx, "model", None)
-        alias = getattr(ctx, "op", None)
-        specs = ctx.get("specs")
-        if (
-            isinstance(model, type)
-            and isinstance(alias, str)
-            and isinstance(specs, Mapping)
-        ):
-            try:
-                cached_views = getattr(model, _OPVIEW_CACHE_ATTR, None)
-                if not isinstance(cached_views, dict):
-                    cached_views = {}
-                    setattr(model, _OPVIEW_CACHE_ATTR, cached_views)
-
-                cached_view = cached_views.get(alias)
-                if cached_view is not None:
-                    ctx.opview = cached_view
-                else:
-                    from tigrbl_kernel.opview_compiler import compile_opview_from_specs
-
-                    op_spec = next(
-                        (
-                            sp
-                            for sp in (
-                                getattr(getattr(model, "ops", None), "all", ()) or ()
-                            )
-                            if getattr(sp, "alias", None) == alias
-                        ),
-                        None,
-                    )
-                    if op_spec is None:
-                        op_spec = SimpleNamespace(alias=alias)
-                    compiled_view = compile_opview_from_specs(specs, op_spec)
-                    cached_views[alias] = compiled_view
-                    ctx.opview = compiled_view
-            except Exception:
-                pass
     skip_persist: bool = bool(ctx.get(CTX_SKIP_PERSIST_FLAG) or ctx.get("skip_persist"))
+    skip_ingress: bool = bool(ctx.get("skip_ingress"))
     skip_egress: bool = bool(ctx.get("skip_egress"))
+    skip_post_commit: bool = bool(ctx.get("skip_post_commit"))
     if not callable(ctx.get("rpc_error_builder")):
         ctx["rpc_error_builder"] = lambda exc: to_rpc_error_payload(
             create_standardized_error(exc)
@@ -156,15 +111,16 @@ async def _invoke(
                 return
             raise create_standardized_error(exc)
 
-    await _run_phase(
-        "INGRESS_BEGIN", allow_flush=False, allow_commit=False, in_tx=False
-    )
-    await _run_phase(
-        "INGRESS_PARSE", allow_flush=False, allow_commit=False, in_tx=False
-    )
-    await _run_phase(
-        "INGRESS_ROUTE", allow_flush=False, allow_commit=False, in_tx=False
-    )
+    if not skip_ingress:
+        await _run_phase(
+            "INGRESS_BEGIN", allow_flush=False, allow_commit=False, in_tx=False
+        )
+        await _run_phase(
+            "INGRESS_PARSE", allow_flush=False, allow_commit=False, in_tx=False
+        )
+        await _run_phase(
+            "INGRESS_ROUTE", allow_flush=False, allow_commit=False, in_tx=False
+        )
     await _run_phase("PRE_TX_BEGIN", allow_flush=False, allow_commit=False, in_tx=False)
 
     if not skip_persist:
@@ -231,7 +187,6 @@ async def _invoke(
         current_result = getattr(ctx, "obj", None)
 
     current_result = _unwrap_ctx_result(current_result)
-    current_result = await _crud_result_fallback(ctx, current_result)
 
     if isinstance(rpc_error, Mapping):
         ctx["result"] = None
@@ -254,7 +209,10 @@ async def _invoke(
     else:
         setattr(response_obj, "result", ctx.get("result"))
 
-    await _run_phase("POST_COMMIT", allow_flush=True, allow_commit=False, in_tx=False)
+    if not skip_post_commit:
+        await _run_phase(
+            "POST_COMMIT", allow_flush=True, allow_commit=False, in_tx=False
+        )
 
     if not skip_egress:
         await _run_phase(
@@ -321,56 +279,4 @@ async def _invoke(
         ctx["result"] = result
     return result
 
-
-async def invoke_op(
-    *,
-    request: Any = None,
-    db: Any = None,
-    model: type,
-    alias: str,
-    ctx: Optional[MutableMapping[str, Any]] = None,
-) -> Any:
-    """Resolve phases and execute an operation through runtime invocation."""
-    seed_ctx: MutableMapping[str, Any] = dict(ctx or {})
-    seed_ctx.setdefault("model", model)
-    seed_ctx.setdefault("op", alias)
-    seed_ctx.setdefault("method", alias)
-    if request is not None:
-        seed_ctx.setdefault("request", request)
-    if db is not None:
-        seed_ctx.setdefault("db", db)
-    if seed_ctx.get("env") is None:
-        seed_ctx["env"] = SimpleNamespace(method=alias)
-    seed_ctx.setdefault("skip_egress", True)
-
-    app_ref = (
-        getattr(request, "app", None)
-        or seed_ctx.get("app")
-        or seed_ctx.get("router")
-        or model
-    )
-    seed_ctx.setdefault("app", app_ref)
-    seed_ctx.setdefault("router", seed_ctx.get("router") or app_ref)
-
-    if seed_ctx.get("specs") is None:
-        specs = get_cached_specs(model)
-        if specs is not None:
-            seed_ctx["specs"] = specs
-
-    if seed_ctx.get("opview") is None:
-        try:
-            seed_ctx["opview"] = _default_kernel.get_opview(app_ref, model, alias)
-        except Exception:
-            # Some call paths rely only on specs/schemas and can proceed without
-            # a compiled opview.
-            pass
-
-    return await _invoke(
-        request=request,
-        db=db,
-        phases=resolve_phase_chains(model, alias),
-        ctx=seed_ctx,
-    )
-
-
-__all__ = ["_invoke", "resolve_phase_chains", "invoke_op"]
+__all__ = ["_invoke"]

{tigrbl_runtime-0.4.4.dev1 → tigrbl_runtime-0.4.4.dev7}/tigrbl_runtime/runtime/runtime.py

@@ -10,15 +10,18 @@ from tigrbl_runtime.executors import (
     NumbaPackedPlanExecutor,
     PackedPlanExecutor,
 )
-from tigrbl_runtime.rust import (
-    ExecutionBackend,
-    RustBackendConfig,
-    reject_rust_backend,
-    RustBindingsUnavailableError,
-)
 from .base import RuntimeBase
 
 
+def _normalize_execution_backend(value: Any) -> str:
+    lowered = str(value or "auto").strip().lower()
+    if not lowered:
+        return "auto"
+    if lowered in {"auto", "python"}:
+        return lowered
+    raise ValueError(f"unsupported execution backend: {value!r}")
+
+
 class Runtime(RuntimeBase):
     """Runtime orchestrator for kernel + executors."""
 
@@ -27,30 +30,16 @@ class Runtime(RuntimeBase):
         kernel: Kernel | None = None,
         *,
         default_executor: str = "packed",
-        kernel_backend: str | ExecutionBackend = ExecutionBackend.AUTO,
-        atoms_backend: str | ExecutionBackend = ExecutionBackend.AUTO,
-        executor_backend: str | ExecutionBackend = ExecutionBackend.PYTHON,
-        rust_backend: RustBackendConfig | None = None,
+        kernel_backend: str = "auto",
+        atoms_backend: str = "auto",
+        executor_backend: str = "python",
     ) -> None:
         resolved_kernel = kernel if kernel is not None else _kernel()
         super().__init__(kernel=resolved_kernel)
         self.default_executor = default_executor
-        self.kernel_backend = reject_rust_backend(
-            kernel_backend,
-            label="kernel_backend",
-        )
-        self.atoms_backend = reject_rust_backend(
-            atoms_backend,
-            label="atoms_backend",
-        )
-        self.executor_backend = reject_rust_backend(
-            executor_backend,
-            label="executor_backend",
-        )
-        self.rust_backend = rust_backend or RustBackendConfig(
-            backend=self.executor_backend
-        )
-        reject_rust_backend(self.rust_backend, label="rust_backend")
+        self.kernel_backend = _normalize_execution_backend(kernel_backend)
+        self.atoms_backend = _normalize_execution_backend(atoms_backend)
+        self.executor_backend = _normalize_execution_backend(executor_backend)
         self.register_executor(PackedPlanExecutor())
         self.register_executor(NumbaPackedPlanExecutor())
 
@@ -66,36 +55,6 @@ class Runtime(RuntimeBase):
         except Exception:
             return 0
 
-    def _uses_rust_executor(self) -> bool:
-        return False
-
-    def _compile_rust(self, app: Any) -> tuple[Any, Any]:
-        del app
-        raise RustBindingsUnavailableError(
-            "Runtime._compile_rust is unavailable. "
-            "Tigrbl runtime execution is Python-only."
-        )
-
-    def rust_handle(self, app: Any) -> Any:
-        del app
-        raise RustBindingsUnavailableError(
-            "Runtime.rust_handle is unavailable. "
-            "Tigrbl runtime execution is Python-only."
-        )
-
-    def execute_rust(
-        self,
-        envelope: Any,
-        *,
-        app: Any | None = None,
-        handle: Any | None = None,
-    ) -> dict[str, Any]:
-        del envelope, app, handle
-        raise RustBindingsUnavailableError(
-            "Runtime.execute_rust is unavailable. "
-            "Tigrbl runtime execution is Python-only."
-        )
-
     def compile(self, *args: Any, **kwargs: Any) -> tuple[Any, Any | None]:
         if args:
             app = args[0]

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/executors/kernel_executor.py

@@ -1,30 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .invoke import _invoke
-from .types import _Ctx
-from tigrbl_typing.phases import canonicalize_phase_input as normalize_phase
-
-
-async def _run(
-    self,
-    model: type,
-    alias: str,
-    *,
-    db: Any,
-    request: Any | None = None,
-    ctx: Any | None = None,
-) -> Any:
-    phases = self._build_op(model, alias)
-    base_ctx = _Ctx.ensure(request=request, db=db, seed=ctx)
-    return await _invoke(request=request, db=db, phases=phases, ctx=base_ctx)
-
-
-async def _run_phase_chain(self, ctx: _Ctx, phases: Any) -> None:
-    for _phase, steps in (phases or {}).items():
-        ctx.phase = normalize_phase(_phase)
-        for step in steps or ():
-            rv = step(ctx)
-            if hasattr(rv, "__await__"):
-                await rv

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/handle.py

@@ -1,19 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any
-import warnings
-
-
-@dataclass(slots=True)
-class RustRuntimeHandleRef:
-    description: str
-    backend: str = "deprecated-rust"
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-    def __post_init__(self) -> None:
-        warnings.warn(
-            "RustRuntimeHandleRef is deprecated; Tigrbl runtime execution is Python-only.",
-            DeprecationWarning,
-            stacklevel=2,
-        )

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/rust/__init__.py

@@ -1,67 +0,0 @@
-from __future__ import annotations
-
-from .backend import (
-    ExecutionBackend,
-    RustBackendConfig,
-    coerce_execution_backend,
-    reject_rust_backend,
-    wants_rust_backend,
-)
-from .callbacks import (
-    register_python_atom,
-    register_python_callback,
-    register_python_engine,
-    register_python_handler,
-    register_python_hook,
-    registered_python_callbacks,
-)
-from .codec import (
-    build_rust_app_spec,
-    coerce_rust_spec_dict,
-    coerce_rust_spec_json,
-)
-from .compile import compile_app, normalize_spec
-from .request import RustRequest
-from .response import RustResponse
-from .errors import RustBindingsUnavailableError, RustSupportDeprecatedError
-from .runtime import (
-    RustRuntimeHandle,
-    create_runtime,
-    create_runtime_from_compiled,
-)
-from .trace import (
-    clear_ffi_boundary_events,
-    compiled_extension_available,
-    ffi_boundary_events,
-    rust_available,
-)
-
-__all__ = [
-    "ExecutionBackend",
-    "RustBackendConfig",
-    "RustBindingsUnavailableError",
-    "RustSupportDeprecatedError",
-    "RustRequest",
-    "RustResponse",
-    "RustRuntimeHandle",
-    "build_rust_app_spec",
-    "clear_ffi_boundary_events",
-    "coerce_rust_spec_dict",
-    "coerce_rust_spec_json",
-    "coerce_execution_backend",
-    "compile_app",
-    "compiled_extension_available",
-    "create_runtime",
-    "create_runtime_from_compiled",
-    "ffi_boundary_events",
-    "rust_available",
-    "normalize_spec",
-    "register_python_atom",
-    "register_python_callback",
-    "register_python_engine",
-    "register_python_handler",
-    "register_python_hook",
-    "registered_python_callbacks",
-    "reject_rust_backend",
-    "wants_rust_backend",
-]

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/rust/_fallback.py

@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .errors import raise_rust_deprecated, warn_rust_deprecated
-
-_BOUNDARY_EVENTS: list[dict[str, Any]] = []
-
-
-def ffi_boundary_events() -> list[dict[str, Any]]:
-    warn_rust_deprecated()
-    return [dict(item) for item in _BOUNDARY_EVENTS]
-
-
-def clear_ffi_boundary_events() -> None:
-    warn_rust_deprecated()
-    _BOUNDARY_EVENTS.clear()
-
-
-def rust_available() -> bool:
-    warn_rust_deprecated()
-    return False
-
-
-def compiled_extension_available() -> bool:
-    warn_rust_deprecated()
-    return False
-
-
-def normalize_spec(spec_json: str) -> str:
-    del spec_json
-    raise_rust_deprecated("tigrbl_runtime.rust._fallback.normalize_spec")
-
-
-def compile_spec(spec_json: str) -> str:
-    del spec_json
-    raise_rust_deprecated("tigrbl_runtime.rust._fallback.compile_spec")
-
-
-class RuntimeHandle:
-    def __init__(self, plan_json_payload: str) -> None:
-        del plan_json_payload
-        raise_rust_deprecated("tigrbl_runtime.rust._fallback.RuntimeHandle")
-
-
-def create_runtime_handle(plan_json: str) -> RuntimeHandle:
-    del plan_json
-    raise_rust_deprecated("tigrbl_runtime.rust._fallback.create_runtime_handle")
-
-
-def register_python_callback(name: str, *_args: Any, **_kwargs: Any) -> str:
-    del name
-    raise_rust_deprecated("tigrbl_runtime.rust._fallback.register_python_callback")
-
-
-def register_python_atom(name: str, *_args: Any, **_kwargs: Any) -> str:
-    del name
-    raise_rust_deprecated("tigrbl_runtime.rust._fallback.register_python_atom")
-
-
-def register_python_hook(name: str, *_args: Any, **_kwargs: Any) -> str:
-    del name
-    raise_rust_deprecated("tigrbl_runtime.rust._fallback.register_python_hook")
-
-
-def register_python_handler(name: str, *_args: Any, **_kwargs: Any) -> str:
-    del name
-    raise_rust_deprecated("tigrbl_runtime.rust._fallback.register_python_handler")
-
-
-def register_python_engine(name: str, *_args: Any, **_kwargs: Any) -> str:
-    del name
-    raise_rust_deprecated("tigrbl_runtime.rust._fallback.register_python_engine")

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/rust/_load_rust.py

@@ -1,22 +0,0 @@
-from __future__ import annotations
-
-from types import ModuleType
-
-from .errors import RUST_DEPRECATION_MESSAGE
-
-
-_LOADED: ModuleType | None = None
-_IMPORT_ERROR: Exception | None = None
-
-
-def load_rust_module() -> tuple[ModuleType, Exception | None]:
-    global _LOADED, _IMPORT_ERROR
-
-    if _LOADED is not None:
-        return _LOADED, _IMPORT_ERROR
-
-    from . import _fallback as module
-
-    _LOADED = module
-    _IMPORT_ERROR = RuntimeError(RUST_DEPRECATION_MESSAGE)
-    return _LOADED, _IMPORT_ERROR

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/rust/availability.py

@@ -1,5 +0,0 @@
-from __future__ import annotations
-
-from .trace import compiled_extension_available, rust_available
-
-__all__ = ["compiled_extension_available", "rust_available"]

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/rust/backend.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from enum import Enum
-
-from .errors import raise_rust_deprecated, warn_rust_deprecated
-
-
-class ExecutionBackend(str, Enum):
-    AUTO = "auto"
-    PYTHON = "python"
-    RUST = "rust"
-
-
-@dataclass(slots=True, frozen=True)
-class RustBackendConfig:
-    backend: ExecutionBackend = ExecutionBackend.AUTO
-    allow_python_callbacks: bool = True
-    emit_boundary_trace: bool = False
-    strict_rust: bool = False
-
-
-def coerce_execution_backend(value: str | ExecutionBackend | None) -> ExecutionBackend:
-    if isinstance(value, ExecutionBackend):
-        if value is ExecutionBackend.RUST:
-            warn_rust_deprecated()
-        return value
-    if value is None:
-        return ExecutionBackend.AUTO
-    lowered = str(value).strip().lower()
-    for item in ExecutionBackend:
-        if item.value == lowered:
-            if item is ExecutionBackend.RUST:
-                warn_rust_deprecated()
-            return item
-    raise ValueError(f"unsupported execution backend: {value!r}")
-
-
-def wants_rust_backend(value: str | ExecutionBackend | RustBackendConfig | None) -> bool:
-    if isinstance(value, RustBackendConfig):
-        backend = value.backend
-    else:
-        backend = coerce_execution_backend(value)
-    if backend is ExecutionBackend.RUST:
-        warn_rust_deprecated()
-    return False
-
-
-def reject_rust_backend(
-    value: str | ExecutionBackend | RustBackendConfig | None,
-    *,
-    label: str,
-) -> ExecutionBackend:
-    if isinstance(value, RustBackendConfig):
-        if value.strict_rust:
-            raise_rust_deprecated(f"{label}.strict_rust")
-        backend = value.backend
-    else:
-        backend = coerce_execution_backend(value)
-    if backend is ExecutionBackend.RUST:
-        raise_rust_deprecated(label)
-    return backend

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/rust/callbacks.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import Any
-
-from .errors import raise_rust_deprecated
-from .trace import record_python_ffi_event
-
-_REGISTRY: dict[str, Callable[..., Any]] = {}
-
-
-def registered_python_callbacks() -> dict[str, Callable[..., Any]]:
-    return dict(_REGISTRY)
-
-
-def register_python_callback(name: str, callback: Callable[..., Any]) -> str:
-    del callback
-    record_python_ffi_event("rust_callback_deprecated", name=name)
-    raise_rust_deprecated("tigrbl_runtime.rust.register_python_callback")
-
-
-def register_python_atom(name: str, callback: Callable[..., Any]) -> str:
-    del callback
-    record_python_ffi_event("rust_atom_deprecated", name=name)
-    raise_rust_deprecated("tigrbl_runtime.rust.register_python_atom")
-
-
-def register_python_hook(name: str, callback: Callable[..., Any]) -> str:
-    del callback
-    record_python_ffi_event("rust_hook_deprecated", name=name)
-    raise_rust_deprecated("tigrbl_runtime.rust.register_python_hook")
-
-
-def register_python_handler(name: str, callback: Callable[..., Any]) -> str:
-    del callback
-    record_python_ffi_event("rust_handler_deprecated", name=name)
-    raise_rust_deprecated("tigrbl_runtime.rust.register_python_handler")
-
-
-def register_python_engine(name: str, callback: Callable[..., Any] | None = None) -> str:
-    del callback
-    record_python_ffi_event("rust_engine_deprecated", name=name)
-    raise_rust_deprecated("tigrbl_runtime.rust.register_python_engine")

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/rust/codec.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .errors import raise_rust_deprecated
-
-
-def build_rust_app_spec(app: Any) -> dict[str, Any]:
-    del app
-    raise_rust_deprecated("tigrbl_runtime.rust.codec.build_rust_app_spec")
-
-
-def coerce_rust_spec_dict(app: Any) -> dict[str, Any]:
-    del app
-    raise_rust_deprecated("tigrbl_runtime.rust.codec.coerce_rust_spec_dict")
-
-
-def coerce_rust_spec_json(app: Any) -> str:
-    del app
-    raise_rust_deprecated("tigrbl_runtime.rust.codec.coerce_rust_spec_json")
-
-
-__all__ = [
-    "build_rust_app_spec",
-    "coerce_rust_spec_dict",
-    "coerce_rust_spec_json",
-]

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/rust/compile.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .errors import raise_rust_deprecated
-
-
-def normalize_spec(spec: Any) -> str:
-    del spec
-    raise_rust_deprecated("tigrbl_runtime.rust.normalize_spec")
-
-
-def compile_app(spec: Any) -> dict[str, Any]:
-    del spec
-    raise_rust_deprecated("tigrbl_runtime.rust.compile_app")

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/rust/errors.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-import warnings
-from typing import NoReturn
-
-
-RUST_DEPRECATION_MESSAGE = (
-    "Tigrbl Rust runtime support is deprecated and unavailable; "
-    "Tigrbl runtime execution is Python-only. Use executor_backend='python'."
-)
-
-
-class RustSupportDeprecatedError(RuntimeError):
-    """Raised when deprecated Rust support is requested."""
-
-
-class RustBindingsUnavailableError(RustSupportDeprecatedError):
-    """Raised when the deprecated Rust runtime binding surface is requested."""
-
-
-def warn_rust_deprecated(*, stacklevel: int = 2) -> None:
-    warnings.warn(RUST_DEPRECATION_MESSAGE, DeprecationWarning, stacklevel=stacklevel)
-
-
-def raise_rust_deprecated(action: str) -> NoReturn:
-    warn_rust_deprecated(stacklevel=3)
-    raise RustBindingsUnavailableError(f"{action} is unavailable. {RUST_DEPRECATION_MESSAGE}")

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/rust/request.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from typing import Any
-import warnings
-
-
-@dataclass(slots=True)
-class RustRequest:
-    operation: str = ""
-    transport: str = "rest"
-    path: str = ""
-    method: str = ""
-    path_params: dict[str, Any] = field(default_factory=dict)
-    query_params: dict[str, Any] = field(default_factory=dict)
-    headers: dict[str, str] = field(default_factory=dict)
-    body: Any = None
-
-    def __post_init__(self) -> None:
-        warnings.warn(
-            "RustRequest is deprecated; Tigrbl runtime execution is Python-only.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-    def asdict(self) -> dict[str, Any]:
-        return asdict(self)

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/rust/response.py

@@ -1,22 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from typing import Any
-import warnings
-
-
-@dataclass(slots=True)
-class RustResponse:
-    status: int = 200
-    headers: dict[str, str] = field(default_factory=dict)
-    body: Any = None
-
-    def __post_init__(self) -> None:
-        warnings.warn(
-            "RustResponse is deprecated; Tigrbl runtime execution is Python-only.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-    def asdict(self) -> dict[str, Any]:
-        return asdict(self)

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/rust/runtime.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any
-
-from .errors import raise_rust_deprecated
-
-
-@dataclass(slots=True)
-class RustRuntimeHandle:
-    _handle: Any = None
-
-    def describe(self) -> str:
-        raise_rust_deprecated("RustRuntimeHandle.describe")
-
-    def plan(self) -> dict[str, object]:
-        raise_rust_deprecated("RustRuntimeHandle.plan")
-
-    def execute_rest(self, envelope: Any) -> dict[str, object]:
-        del envelope
-        raise_rust_deprecated("RustRuntimeHandle.execute_rest")
-
-    def execute_jsonrpc(self, envelope: Any) -> dict[str, object]:
-        del envelope
-        raise_rust_deprecated("RustRuntimeHandle.execute_jsonrpc")
-
-    def execute_ws(self, envelope: Any) -> dict[str, object]:
-        del envelope
-        raise_rust_deprecated("RustRuntimeHandle.execute_ws")
-
-    def execute_stream(self, envelope: Any) -> dict[str, object]:
-        del envelope
-        raise_rust_deprecated("RustRuntimeHandle.execute_stream")
-
-    def execute_sse(self, envelope: Any) -> dict[str, object]:
-        del envelope
-        raise_rust_deprecated("RustRuntimeHandle.execute_sse")
-
-    def begin_request(self, transport: str = "rest") -> None:
-        del transport
-        raise_rust_deprecated("RustRuntimeHandle.begin_request")
-
-    def callback_fence(self, kind: str, name: str) -> None:
-        del kind, name
-        raise_rust_deprecated("RustRuntimeHandle.callback_fence")
-
-    def finish_response(self, transport: str = "rest") -> None:
-        del transport
-        raise_rust_deprecated("RustRuntimeHandle.finish_response")
-
-    def ffi_events(self) -> list[dict[str, object]]:
-        raise_rust_deprecated("RustRuntimeHandle.ffi_events")
-
-
-def create_runtime_from_compiled(plan: Any) -> RustRuntimeHandle:
-    del plan
-    raise_rust_deprecated("tigrbl_runtime.rust.create_runtime_from_compiled")
-
-
-def create_runtime(spec: Any) -> RustRuntimeHandle:
-    del spec
-    raise_rust_deprecated("tigrbl_runtime.rust.create_runtime")

tigrbl_runtime-0.4.4.dev1/tigrbl_runtime/rust/trace.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-from .errors import warn_rust_deprecated
-
-_PYTHON_FFI_EVENTS: list[dict[str, object]] = []
-
-
-def ffi_boundary_events() -> list[dict[str, object]]:
-    warn_rust_deprecated()
-    return list(_PYTHON_FFI_EVENTS)
-
-
-def clear_ffi_boundary_events() -> None:
-    warn_rust_deprecated()
-    _PYTHON_FFI_EVENTS.clear()
-
-
-def record_python_ffi_event(event: str, **payload: object) -> None:
-    _PYTHON_FFI_EVENTS.append({"event": event, **payload})
-
-
-def rust_available() -> bool:
-    warn_rust_deprecated()
-    return False
-
-
-def compiled_extension_available() -> bool:
-    warn_rust_deprecated()
-    return False