tigrbl-core 0.1.12.dev1__tar.gz → 0.4.0.dev2__tar.gz

{tigrbl_core-0.1.12.dev1 → tigrbl_core-0.4.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl-core
-Version: 0.1.12.dev1
+Version: 0.4.0.dev2
 Summary: Core specifications and primitives for the Tigrbl framework.
 License-Expression: Apache-2.0
 Keywords: tigrbl,sdk,standards,framework
@@ -20,6 +20,11 @@ Requires-Dist: pyyaml
 Requires-Dist: tigrbl-typing
 Requires-Dist: tomli (>=2.0.1) ; python_version < "3.11"
 Requires-Dist: tomli-w
+Project-URL: Discord, https://discord.gg/K4YTAPapjR
+Project-URL: Homepage, https://github.com/tigrbl/tigrbl
+Project-URL: Issues, https://github.com/tigrbl/tigrbl/issues
+Project-URL: Organization, https://github.com/tigrbl
+Project-URL: Repository, https://github.com/tigrbl/tigrbl/tree/master/pkgs/core/tigrbl_core
 Description-Content-Type: text/markdown
 
 # tigrbl_core
@@ -40,6 +45,10 @@ It is not the authoritative location for repository governance, current target s
 
 ## Package identity
 
+- canonical repository: `https://github.com/tigrbl/tigrbl`
+- organization: `https://github.com/tigrbl`
+- social: `https://discord.gg/K4YTAPapjR`
+- package path: `https://github.com/tigrbl/tigrbl/tree/master/pkgs/core/tigrbl_core`
 - workspace path: `pkgs/core/tigrbl_core`
 - workspace class: core Python package
 - implementation layout: `tigrbl_core/`

{tigrbl_core-0.1.12.dev1 → tigrbl_core-0.4.0.dev2}/README.md

@@ -16,6 +16,10 @@ It is not the authoritative location for repository governance, current target s
 
 ## Package identity
 
+- canonical repository: `https://github.com/tigrbl/tigrbl`
+- organization: `https://github.com/tigrbl`
+- social: `https://discord.gg/K4YTAPapjR`
+- package path: `https://github.com/tigrbl/tigrbl/tree/master/pkgs/core/tigrbl_core`
 - workspace path: `pkgs/core/tigrbl_core`
 - workspace class: core Python package
 - implementation layout: `tigrbl_core/`

{tigrbl_core-0.1.12.dev1 → tigrbl_core-0.4.0.dev2}/pyproject.toml

@@ -1,10 +1,9 @@
 [project]
 name = "tigrbl-core"
-version = "0.1.12.dev1"
+version = "0.4.0.dev2"
 description = "Core specifications and primitives for the Tigrbl framework."
 license = "Apache-2.0"
 readme = "README.md"
-repository = "http://github.com/swarmauri/swarmauri-sdk"
 requires-python = ">=3.10,<3.14"
 classifiers = [
     "Development Status :: 1 - Planning",
@@ -17,6 +16,7 @@ classifiers = [
     "Programming Language :: Python :: 3 :: Only",
 ]
 authors = [{ name = "Jacob Stewart", email = "jacob@swarmauri.com" }]
+
 dependencies = [
     "tigrbl-typing",
     "pydantic>=2.10,<3",
@@ -26,6 +26,14 @@ dependencies = [
 ]
 keywords = ["tigrbl", "sdk", "standards", "framework"]
 
+
+[project.urls]
+Organization = "https://github.com/tigrbl"
+Discord = "https://discord.gg/K4YTAPapjR"
+Homepage = "https://github.com/tigrbl/tigrbl"
+Repository = "https://github.com/tigrbl/tigrbl/tree/master/pkgs/core/tigrbl_core"
+Issues = "https://github.com/tigrbl/tigrbl/issues"
+
 [tool.uv.sources]
 "tigrbl-typing" = { workspace = true }
 

tigrbl_core-0.4.0.dev2/tigrbl_core/_spec/binding_spec.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Type, Union
+
+from ..config.constants import (
+    TIGRBL_NESTED_PATHS_ATTR,
+    __JSONRPC_DEFAULT_ENDPOINT__,
+)
+from .serde import SerdeMixin
+
+Exchange = Literal[
+    "request_response",
+    "server_stream",
+    "event_stream",
+    "client_stream",
+    "bidirectional",
+    "bidirectional_stream",
+    "fire_and_forget",
+]
+Framing = Literal["json", "jsonrpc", "sse", "stream", "text", "bytes", "webtransport"]
+
+
+@dataclass(frozen=True, slots=True)
+class HttpRestBindingSpec(SerdeMixin):
+    proto: Literal["http.rest", "https.rest"]
+    methods: tuple[str, ...]
+    path: str
+    exchange: Exchange = "request_response"
+    framing: Framing = "json"
+
+
+@dataclass(frozen=True, slots=True)
+class HttpJsonRpcBindingSpec(SerdeMixin):
+    proto: Literal["http.jsonrpc", "https.jsonrpc"]
+    rpc_method: str
+    endpoint: str = __JSONRPC_DEFAULT_ENDPOINT__
+    exchange: Exchange = "request_response"
+    framing: Framing = "jsonrpc"
+
+
+@dataclass(frozen=True, slots=True)
+class HttpStreamBindingSpec(SerdeMixin):
+    proto: Literal["http.stream", "https.stream"]
+    path: str
+    methods: tuple[str, ...] = ("GET",)
+    exchange: Exchange = "server_stream"
+    framing: Framing = "stream"
+
+
+@dataclass(frozen=True, slots=True)
+class SseBindingSpec(SerdeMixin):
+    proto: Literal["http.sse", "https.sse"] = "http.sse"
+    path: str = "/"
+    methods: tuple[str, ...] = ("GET",)
+    exchange: Exchange = "server_stream"
+    framing: Framing = "sse"
+
+
+@dataclass(frozen=True, slots=True)
+class WsBindingSpec(SerdeMixin):
+    proto: Literal["ws", "wss"]
+    path: str
+    subprotocols: tuple[str, ...] = ()
+    exchange: Exchange = "bidirectional_stream"
+    framing: Framing = "text"
+
+
+@dataclass(frozen=True, slots=True)
+class WebTransportBindingSpec(SerdeMixin):
+    proto: Literal["webtransport"] = "webtransport"
+    path: str = "/"
+    exchange: Exchange = "bidirectional_stream"
+    framing: Framing = "webtransport"
+
+
+@dataclass(frozen=True, slots=True)
+class MessageBindingSpec(SerdeMixin):
+    proto: str
+    topic: str
+    exchange: Exchange = "fire_and_forget"
+    framing: Framing = "bytes"
+
+
+@dataclass(frozen=True, slots=True)
+class DatagramBindingSpec(SerdeMixin):
+    proto: str
+    endpoint: str
+    exchange: Exchange = "fire_and_forget"
+    framing: Framing = "bytes"
+
+
+TransportBindingSpec = Union[
+    HttpRestBindingSpec,
+    HttpJsonRpcBindingSpec,
+    HttpStreamBindingSpec,
+    SseBindingSpec,
+    WsBindingSpec,
+    WebTransportBindingSpec,
+    MessageBindingSpec,
+    DatagramBindingSpec,
+]
+
+
+@dataclass(frozen=True, slots=True)
+class BindingSpec(SerdeMixin):
+    """Named binding declaration used for registry composition."""
+
+    name: str
+    spec: TransportBindingSpec
+
+
+@dataclass(slots=True)
+class BindingRegistrySpec(SerdeMixin):
+    """Simple in-memory registry for named transport bindings."""
+
+    _bindings: dict[str, BindingSpec] = field(default_factory=dict)
+
+    def register(self, binding: BindingSpec) -> None:
+        self._bindings[binding.name] = binding
+
+    def get(self, name: str) -> Optional[BindingSpec]:
+        return self._bindings.get(name)
+
+    def values(self) -> tuple[BindingSpec, ...]:
+        return tuple(self._bindings.values())
+
+
+def resolve_rest_nested_prefix(model: Type) -> Optional[str]:
+    """Return the configured nested REST prefix for ``model`` if present."""
+
+    cb = getattr(model, TIGRBL_NESTED_PATHS_ATTR, None)
+    if callable(cb):
+        return cb()
+    return getattr(model, "_nested_path", None)
+
+
+_EXCHANGE_ALIASES = {
+    "bidirectional": "bidirectional_stream",
+    "event_stream": "server_stream",
+}
+_CANONICAL_EXCHANGES = {
+    "request_response",
+    "server_stream",
+    "client_stream",
+    "bidirectional_stream",
+    "fire_and_forget",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class BindingEventKey:
+    family: str
+    family_code: int
+
+
+def normalize_exchange(exchange: str | None) -> str:
+    token = str(exchange or "")
+    normalized = _EXCHANGE_ALIASES.get(token, token)
+    if normalized not in _CANONICAL_EXCHANGES:
+        raise ValueError(f"invalid exchange token {exchange!r}; expected canonical exchange")
+    return normalized
+
+
+def matches_exchange_selector(*, selector: str, exchange: str | None) -> bool:
+    return normalize_exchange(selector) == normalize_exchange(exchange)
+
+
+def project_binding_runtime_metadata(binding: TransportBindingSpec) -> dict[str, object]:
+    proto = str(getattr(binding, "proto", ""))
+    exchange = normalize_exchange(getattr(binding, "exchange", None))
+    framing = str(getattr(binding, "framing", ""))
+    family = _binding_family(binding)
+    _validate_binding_exchange(family, exchange)
+    return {
+        "proto": proto,
+        "exchange": exchange,
+        "framing": framing,
+        "family": family,
+        "subevents": _binding_subevents(family),
+    }
+
+
+def compile_binding_event_key(binding: TransportBindingSpec) -> BindingEventKey:
+    family = str(project_binding_runtime_metadata(binding)["family"])
+    codes = {
+        "request_response": 10,
+        "rpc": 11,
+        "stream": 20,
+        "event_stream": 21,
+        "socket": 30,
+        "transport": 31,
+        "message": 40,
+        "datagram": 41,
+    }
+    return BindingEventKey(family=family, family_code=codes[family])
+
+
+def _binding_family(binding: TransportBindingSpec) -> str:
+    if isinstance(binding, HttpJsonRpcBindingSpec):
+        return "rpc"
+    if isinstance(binding, HttpStreamBindingSpec):
+        return "stream"
+    if isinstance(binding, SseBindingSpec):
+        return "event_stream"
+    if isinstance(binding, WsBindingSpec):
+        return "socket"
+    if isinstance(binding, WebTransportBindingSpec):
+        return "transport"
+    if isinstance(binding, MessageBindingSpec):
+        return "message"
+    if isinstance(binding, DatagramBindingSpec):
+        return "datagram"
+    return "request_response"
+
+
+def _binding_subevents(family: str) -> tuple[str, ...]:
+    subevents = {
+        "request_response": ("request.received", "response.sent"),
+        "rpc": ("rpc.request", "rpc.response"),
+        "stream": ("stream.open", "stream.message", "stream.close"),
+        "event_stream": ("event_stream.open", "event_stream.event", "event_stream.close"),
+        "socket": ("socket.open", "socket.message", "socket.close"),
+        "transport": ("transport.open", "transport.datagram", "transport.close"),
+        "message": ("message.received", "message.processed"),
+        "datagram": ("datagram.received", "datagram.ack"),
+    }
+    return subevents[family]
+
+
+def _validate_binding_exchange(family: str, exchange: str) -> None:
+    allowed = {
+        "request_response": {"request_response"},
+        "rpc": {"request_response"},
+        "stream": {"server_stream"},
+        "event_stream": {"server_stream"},
+        "socket": {"bidirectional_stream"},
+        "transport": {"bidirectional_stream"},
+        "message": {"fire_and_forget"},
+        "datagram": {"fire_and_forget"},
+    }
+    if exchange not in allowed[family]:
+        raise ValueError(
+            f"invalid exchange {exchange!r} for binding family {family!r}; "
+            "expected canonical family exchange"
+        )
+
+
+__all__ = [
+    "BindingSpec",
+    "BindingRegistrySpec",
+    "BindingEventKey",
+    "DatagramBindingSpec",
+    "Exchange",
+    "Framing",
+    "HttpJsonRpcBindingSpec",
+    "HttpRestBindingSpec",
+    "HttpStreamBindingSpec",
+    "MessageBindingSpec",
+    "SseBindingSpec",
+    "TransportBindingSpec",
+    "WebTransportBindingSpec",
+    "WsBindingSpec",
+    "compile_binding_event_key",
+    "matches_exchange_selector",
+    "normalize_exchange",
+    "project_binding_runtime_metadata",
+    "resolve_rest_nested_prefix",
+]

tigrbl_core-0.4.0.dev2/tigrbl_core/_spec/hook_spec.py

@@ -0,0 +1,149 @@
+"""Hook specification for Tigrbl v3."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Optional, Tuple
+
+from .binding_spec import Exchange
+from .hook_types import HookPhase, HookPredicate, StepFn
+
+from .serde import SerdeMixin
+
+
+@dataclass(frozen=True, slots=True)
+class HookSpec(SerdeMixin):
+    phase: HookPhase
+    fn: StepFn
+    ops: str | Tuple[str, ...] = "*"
+    bindings: Tuple[str, ...] = ()
+    framing: Tuple[str, ...] = ()
+    exchange: Optional[Exchange] = None
+    family: Tuple[str, ...] = ()
+    subevents: Tuple[str, ...] = ()
+    order: int = 0
+    when: Optional[HookPredicate] = None
+    name: Optional[str] = None
+    description: Optional[str] = None
+
+    @classmethod
+    def collect(cls, owner: type) -> tuple["HookSpec", ...]:
+        hooks: list[HookSpec] = []
+        for hook in getattr(owner, "HOOKS", ()) or ():
+            if isinstance(hook, HookSpec):
+                hooks.append(hook)
+            elif isinstance(hook, dict):
+                hooks.append(cls(**hook))
+        for _, attr in vars(owner).items():
+            attr = getattr(attr, "__func__", attr)
+            for item in tuple(getattr(attr, "__tigrbl_hook_decls__", ()) or ()):
+                if isinstance(item, HookSpec):
+                    hooks.append(item)
+                elif isinstance(item, dict):
+                    hooks.append(cls(**item))
+            declared = getattr(attr, "__tigrbl_hook_spec__", None)
+            if isinstance(declared, HookSpec):
+                hooks.append(declared)
+            elif isinstance(declared, dict):
+                hooks.append(cls(**declared))
+        return tuple(hooks)
+
+
+_RUNTIME_OWNED_PHASES = frozenset(
+    {
+        "INGRESS_BEGIN",
+        "INGRESS_PARSE",
+        "INGRESS_ROUTE",
+        "INGRESS_DISPATCH",
+        "EGRESS_SHAPE",
+        "EGRESS_FINALIZE",
+        "EMIT",
+        "POST_EMIT",
+    }
+)
+_EXCHANGE_ALIASES = {
+    "event_stream": "server_stream",
+    "sse": "server_stream",
+    "stream": "server_stream",
+}
+
+
+def _as_tuple(value: Any) -> tuple[str, ...]:
+    if value in (None, "", ()):
+        return ()
+    if isinstance(value, str):
+        return (value,)
+    return tuple(str(item) for item in value)
+
+
+def _hook_phase_value(value: Any) -> str:
+    return str(getattr(value, "value", value))
+
+
+def _normalize_exchange(value: Any) -> str | None:
+    if value in (None, ""):
+        return None
+    token = str(value)
+    return _EXCHANGE_ALIASES.get(token, token)
+
+
+def validate_hook_legality(hook: HookSpec) -> None:
+    phase = _hook_phase_value(getattr(hook, "phase", None))
+    if phase in _RUNTIME_OWNED_PHASES:
+        if phase == "POST_EMIT":
+            raise ValueError(f"{phase} is a runtime-owned completion fence, not a hook phase")
+        raise ValueError(f"{phase} is a runtime-owned canonical phase, not a hook phase")
+    try:
+        HookPhase(phase)
+    except ValueError as exc:
+        raise ValueError(f"{phase} is not a governed hook phase") from exc
+
+
+def validate_hook_selector_legality(selector: dict[str, Any]) -> None:
+    phase = selector.get("phase")
+    if phase is not None:
+        validate_hook_legality(HookSpec(phase=phase, fn=lambda _ctx: None))  # type: ignore[arg-type]
+
+
+def matches_hook_selector(hook: HookSpec, metadata: dict[str, Any]) -> bool:
+    validate_hook_legality(hook)
+    hook_ops = getattr(hook, "ops", "*")
+    if hook_ops != "*":
+        op = metadata.get("op") or metadata.get("alias") or metadata.get("method")
+        if op not in _as_tuple(hook_ops):
+            return False
+
+    bindings = _as_tuple(getattr(hook, "bindings", ()))
+    if bindings and str(metadata.get("binding")) not in bindings:
+        return False
+
+    hook_exchange = _normalize_exchange(getattr(hook, "exchange", None))
+    metadata_exchange = _normalize_exchange(metadata.get("exchange"))
+    if hook_exchange is not None and metadata_exchange != hook_exchange:
+        return False
+
+    families = _as_tuple(getattr(hook, "family", ()))
+    if families and str(metadata.get("family")) not in families:
+        return False
+
+    subevents = _as_tuple(getattr(hook, "subevents", ()))
+    if subevents and str(metadata.get("subevent")) not in subevents:
+        return False
+
+    framings = _as_tuple(getattr(hook, "framing", ()))
+    if framings and str(metadata.get("framing")) not in framings:
+        return False
+
+    return True
+
+
+# Backwards compatibility alias
+OpHook = HookSpec
+
+__all__ = [
+    "HookSpec",
+    "OpHook",
+    "matches_hook_selector",
+    "validate_hook_legality",
+    "validate_hook_selector_legality",
+]

{tigrbl_core-0.1.12.dev1 → tigrbl_core-0.4.0.dev2}/tigrbl_core/_spec/hook_types.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from enum import Enum
 from typing import Any, Awaitable, Callable, Tuple
 
+from tigrbl_typing.phases import normalize_phase
+
 
 class HookPhase(str, Enum):
     PRE_TX_BEGIN = "PRE_TX_BEGIN"
@@ -11,7 +13,7 @@ class HookPhase(str, Enum):
     HANDLER = "HANDLER"
     POST_HANDLER = "POST_HANDLER"
     PRE_COMMIT = "PRE_COMMIT"
-    END_TX = "END_TX"
+    TX_COMMIT = "TX_COMMIT"
     POST_COMMIT = "POST_COMMIT"
     POST_RESPONSE = "POST_RESPONSE"
     ON_ERROR = "ON_ERROR"
@@ -21,10 +23,17 @@ class HookPhase(str, Enum):
     ON_HANDLER_ERROR = "ON_HANDLER_ERROR"
     ON_POST_HANDLER_ERROR = "ON_POST_HANDLER_ERROR"
     ON_PRE_COMMIT_ERROR = "ON_PRE_COMMIT_ERROR"
-    ON_END_TX_ERROR = "ON_END_TX_ERROR"
+    ON_TX_COMMIT_ERROR = "ON_TX_COMMIT_ERROR"
     ON_POST_COMMIT_ERROR = "ON_POST_COMMIT_ERROR"
     ON_POST_RESPONSE_ERROR = "ON_POST_RESPONSE_ERROR"
-    ON_ROLLBACK = "ON_ROLLBACK"
+    TX_ROLLBACK = "TX_ROLLBACK"
+
+    @classmethod
+    def _missing_(cls, value: object):
+        normalized = normalize_phase(str(value)) if value is not None else None
+        if normalized != value:
+            return cls(normalized)
+        return None
 
 
 HookPhases: Tuple[HookPhase, ...] = tuple(HookPhase)

{tigrbl_core-0.1.12.dev1 → tigrbl_core-0.4.0.dev2}/tigrbl_core/_spec/serde.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+from base64 import b64decode, b64encode
 from dataclasses import fields, is_dataclass
 from importlib import import_module
 from typing import Any, TypeVar
@@ -25,6 +26,8 @@ def _resolve_path(path: str) -> Any:
 def _serialize_value(value: Any) -> Any:
     if value is None or isinstance(value, (bool, int, float, str)):
         return value
+    if isinstance(value, bytes):
+        return {"__bytes__": b64encode(value).decode("ascii")}
     if is_dataclass(value):
         payload = {
             f.name: _serialize_value(getattr(value, f.name)) for f in fields(value)
@@ -53,6 +56,8 @@ def _deserialize_value(value: Any) -> Any:
     if isinstance(value, dict):
         if "__tuple__" in value:
             return tuple(_deserialize_value(item) for item in value["__tuple__"])
+        if "__bytes__" in value:
+            return b64decode(value["__bytes__"].encode("ascii"))
         if "__class__" in value:
             return _resolve_path(value["__class__"])
         if "__callable__" in value:

{tigrbl_core-0.1.12.dev1 → tigrbl_core-0.4.0.dev2}/tigrbl_core/_spec/session_spec.py

@@ -71,7 +71,7 @@ class SessionSpec(SerdeMixin):
 
     def merge(self, higher: "SessionSpec | Mapping[str, Any] | None") -> "SessionSpec":
         """
-        Overlay another spec on top of this one (non-None fields take precedence).
+        Overlay another spec on top of this one (explicit fields take precedence).
         Use to implement op > model > router > app precedence.
         """
         if higher is None:
@@ -79,13 +79,18 @@ class SessionSpec(SerdeMixin):
         h = higher if isinstance(higher, SessionSpec) else SessionSpec.from_any(higher)
         if h is None:
             return self
+        defaults = SessionSpec()
         vals: MutableMapping[str, Any] = {
             f.name: getattr(self, f.name) for f in fields(SessionSpec)
         }
         for f in fields(SessionSpec):
             hv = getattr(h, f.name)
-            if hv is not None:
-                vals[f.name] = hv
+            if hv is None:
+                continue
+            default = getattr(defaults, f.name)
+            if hv == default and vals[f.name] != default:
+                continue
+            vals[f.name] = hv
         return SessionSpec(**vals)  # type: ignore[arg-type]
 
     def to_kwargs(self) -> dict[str, Any]:

tigrbl_core-0.4.0.dev2/tigrbl_core/canonical_json.py

@@ -0,0 +1,46 @@
+"""RFC 8785-style canonical JSON helpers for proof-bound payloads."""
+
+from __future__ import annotations
+
+import json
+import math
+from decimal import Decimal
+from typing import Any
+
+
+def _reject_non_finite_numbers(value: Any) -> None:
+    if isinstance(value, float) and not math.isfinite(value):
+        raise ValueError("JCS canonical JSON requires finite JSON numbers")
+    if isinstance(value, Decimal) and not value.is_finite():
+        raise ValueError("JCS canonical JSON requires finite JSON numbers")
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if not isinstance(key, str):
+                raise TypeError("JCS canonical JSON object keys must be strings")
+            _reject_non_finite_numbers(item)
+        return
+    if isinstance(value, (list, tuple)):
+        for item in value:
+            _reject_non_finite_numbers(item)
+
+
+def canonicalize(payload: Any) -> str:
+    """Return deterministic UTF-8 JSON text with sorted object members."""
+
+    _reject_non_finite_numbers(payload)
+    return json.dumps(
+        payload,
+        ensure_ascii=False,
+        allow_nan=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    )
+
+
+def canonical_json_bytes(payload: Any) -> bytes:
+    """Return deterministic UTF-8 JSON bytes with JCS rejection semantics."""
+
+    return canonicalize(payload).encode("utf-8")
+
+
+__all__ = ["canonical_json_bytes", "canonicalize"]

tigrbl_core-0.1.12.dev1/tigrbl_core/_spec/binding_spec.py

@@ -1,133 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Literal, Optional, Type, Union
-
-from ..config.constants import (
-    TIGRBL_NESTED_PATHS_ATTR,
-    __JSONRPC_DEFAULT_ENDPOINT__,
-)
-from .serde import SerdeMixin
-
-Exchange = Literal[
-    "request_response",
-    "server_stream",
-    "event_stream",
-    "client_stream",
-    "bidirectional",
-    "bidirectional_stream",
-    "fire_and_forget",
-]
-Framing = Literal["json", "jsonrpc", "sse", "stream", "text", "bytes", "webtransport"]
-
-
-@dataclass(frozen=True, slots=True)
-class HttpRestBindingSpec(SerdeMixin):
-    proto: Literal["http.rest", "https.rest"]
-    methods: tuple[str, ...]
-    path: str
-    exchange: Exchange = "request_response"
-    framing: Framing = "json"
-
-
-@dataclass(frozen=True, slots=True)
-class HttpJsonRpcBindingSpec(SerdeMixin):
-    proto: Literal["http.jsonrpc", "https.jsonrpc"]
-    rpc_method: str
-    endpoint: str = __JSONRPC_DEFAULT_ENDPOINT__
-    exchange: Exchange = "request_response"
-    framing: Framing = "jsonrpc"
-
-
-@dataclass(frozen=True, slots=True)
-class HttpStreamBindingSpec(SerdeMixin):
-    proto: Literal["http.stream", "https.stream"]
-    path: str
-    methods: tuple[str, ...] = ("GET",)
-    exchange: Exchange = "server_stream"
-    framing: Framing = "stream"
-
-
-@dataclass(frozen=True, slots=True)
-class SseBindingSpec(SerdeMixin):
-    proto: Literal["http.sse", "https.sse"] = "http.sse"
-    path: str = "/"
-    methods: tuple[str, ...] = ("GET",)
-    exchange: Exchange = "server_stream"
-    framing: Framing = "sse"
-
-
-@dataclass(frozen=True, slots=True)
-class WsBindingSpec(SerdeMixin):
-    proto: Literal["ws", "wss"]
-    path: str
-    subprotocols: tuple[str, ...] = ()
-    exchange: Exchange = "bidirectional_stream"
-    framing: Framing = "text"
-
-
-@dataclass(frozen=True, slots=True)
-class WebTransportBindingSpec(SerdeMixin):
-    proto: Literal["webtransport"] = "webtransport"
-    path: str = "/"
-    exchange: Exchange = "bidirectional_stream"
-    framing: Framing = "webtransport"
-
-
-TransportBindingSpec = Union[
-    HttpRestBindingSpec,
-    HttpJsonRpcBindingSpec,
-    HttpStreamBindingSpec,
-    SseBindingSpec,
-    WsBindingSpec,
-    WebTransportBindingSpec,
-]
-
-
-@dataclass(frozen=True, slots=True)
-class BindingSpec(SerdeMixin):
-    """Named binding declaration used for registry composition."""
-
-    name: str
-    spec: TransportBindingSpec
-
-
-@dataclass(slots=True)
-class BindingRegistrySpec(SerdeMixin):
-    """Simple in-memory registry for named transport bindings."""
-
-    _bindings: dict[str, BindingSpec] = field(default_factory=dict)
-
-    def register(self, binding: BindingSpec) -> None:
-        self._bindings[binding.name] = binding
-
-    def get(self, name: str) -> Optional[BindingSpec]:
-        return self._bindings.get(name)
-
-    def values(self) -> tuple[BindingSpec, ...]:
-        return tuple(self._bindings.values())
-
-
-def resolve_rest_nested_prefix(model: Type) -> Optional[str]:
-    """Return the configured nested REST prefix for ``model`` if present."""
-
-    cb = getattr(model, TIGRBL_NESTED_PATHS_ATTR, None)
-    if callable(cb):
-        return cb()
-    return getattr(model, "_nested_path", None)
-
-
-__all__ = [
-    "BindingSpec",
-    "BindingRegistrySpec",
-    "Exchange",
-    "Framing",
-    "HttpJsonRpcBindingSpec",
-    "HttpRestBindingSpec",
-    "HttpStreamBindingSpec",
-    "SseBindingSpec",
-    "TransportBindingSpec",
-    "WebTransportBindingSpec",
-    "WsBindingSpec",
-    "resolve_rest_nested_prefix",
-]

tigrbl_core-0.1.12.dev1/tigrbl_core/_spec/hook_spec.py

@@ -1,48 +0,0 @@
-"""Hook specification for Tigrbl v3."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Optional, Tuple
-
-from .binding_spec import Exchange
-from .hook_types import HookPhase, HookPredicate, StepFn
-
-from .serde import SerdeMixin
-
-
-@dataclass(frozen=True, slots=True)
-class HookSpec(SerdeMixin):
-    phase: HookPhase
-    fn: StepFn
-    ops: str | Tuple[str, ...] = "*"
-    bindings: Tuple[str, ...] = ()
-    exchange: Optional[Exchange] = None
-    family: Tuple[str, ...] = ()
-    subevents: Tuple[str, ...] = ()
-    order: int = 0
-    when: Optional[HookPredicate] = None
-    name: Optional[str] = None
-    description: Optional[str] = None
-
-    @classmethod
-    def collect(cls, owner: type) -> tuple["HookSpec", ...]:
-        hooks: list[HookSpec] = []
-        for hook in getattr(owner, "HOOKS", ()) or ():
-            if isinstance(hook, HookSpec):
-                hooks.append(hook)
-            elif isinstance(hook, dict):
-                hooks.append(cls(**hook))
-        for _, attr in vars(owner).items():
-            declared = getattr(attr, "__tigrbl_hook_spec__", None)
-            if isinstance(declared, HookSpec):
-                hooks.append(declared)
-            elif isinstance(declared, dict):
-                hooks.append(cls(**declared))
-        return tuple(hooks)
-
-
-# Backwards compatibility alias
-OpHook = HookSpec
-
-__all__ = ["HookSpec", "OpHook"]