tigrbl-core 0.1.0.dev15__tar.gz → 0.1.11.dev1__tar.gz

tigrbl_core-0.1.11.dev1/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: tigrbl-core
+Version: 0.1.11.dev1
+Summary: Core specifications and primitives for the Tigrbl framework.
+License-Expression: Apache-2.0
+Keywords: tigrbl,sdk,standards,framework
+Author: Jacob Stewart
+Author-email: jacob@swarmauri.com
+Requires-Python: >=3.10,<3.14
+Classifier: Development Status :: 1 - Planning
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Dist: pydantic (>=2.10,<3)
+Requires-Dist: pyyaml
+Requires-Dist: tigrbl-typing
+Requires-Dist: tomli (>=2.0.1) ; python_version < "3.11"
+Requires-Dist: tomli-w
+Description-Content-Type: text/markdown
+
+# tigrbl_core
+
+This file is a package-local distribution entry point.
+It is not the authoritative location for repository governance, current target status, current state reporting, certification claims, or release evidence.
+
+## Canonical repository docs
+
+- `README.md`
+- `docs/README.md`
+- `docs/conformance/CURRENT_TARGET.md`
+- `docs/conformance/CURRENT_STATE.md`
+- `docs/conformance/NEXT_STEPS.md`
+- `docs/governance/DOC_POINTERS.md`
+- `docs/developer/PACKAGE_CATALOG.md`
+- `docs/developer/PACKAGE_LAYOUT.md`
+
+## Package identity
+
+- workspace path: `pkgs/core/tigrbl_core`
+- workspace class: core Python package
+- implementation layout: `tigrbl_core/`
+
+Long-form repository documentation is governed from `docs/`.
+

tigrbl_core-0.1.11.dev1/README.md

@@ -0,0 +1,23 @@
+# tigrbl_core
+
+This file is a package-local distribution entry point.
+It is not the authoritative location for repository governance, current target status, current state reporting, certification claims, or release evidence.
+
+## Canonical repository docs
+
+- `README.md`
+- `docs/README.md`
+- `docs/conformance/CURRENT_TARGET.md`
+- `docs/conformance/CURRENT_STATE.md`
+- `docs/conformance/NEXT_STEPS.md`
+- `docs/governance/DOC_POINTERS.md`
+- `docs/developer/PACKAGE_CATALOG.md`
+- `docs/developer/PACKAGE_LAYOUT.md`
+
+## Package identity
+
+- workspace path: `pkgs/core/tigrbl_core`
+- workspace class: core Python package
+- implementation layout: `tigrbl_core/`
+
+Long-form repository documentation is governed from `docs/`.

{tigrbl_core-0.1.0.dev15 → tigrbl_core-0.1.11.dev1}/pyproject.toml

@@ -1,17 +1,17 @@
 [project]
 name = "tigrbl-core"
-version = "0.1.0.dev15"
+version = "0.1.11.dev1"
 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.13"
+requires-python = ">=3.10,<3.14"
 classifiers = [
-    "License :: OSI Approved :: Apache Software License",
     "Development Status :: 1 - Planning",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",

{tigrbl_core-0.1.0.dev15 → tigrbl_core-0.1.11.dev1}/tigrbl_core/_spec/__init__.py

@@ -13,24 +13,48 @@ _EXPORTS = {
     "AppSpec": "app_spec",
     "BindingSpec": "binding_spec",
     "BindingRegistrySpec": "binding_spec",
+    "Exchange": "binding_spec",
+    "Framing": "binding_spec",
     "TransportBindingSpec": "binding_spec",
     "HttpRestBindingSpec": "binding_spec",
     "HttpJsonRpcBindingSpec": "binding_spec",
+    "HttpStreamBindingSpec": "binding_spec",
+    "SseBindingSpec": "binding_spec",
+    "WebTransportBindingSpec": "binding_spec",
     "WsBindingSpec": "binding_spec",
     "resolve_rest_nested_prefix": "binding_spec",
     "ColumnSpec": "column_spec",
+    "CANONICAL_DATATYPES": "datatypes",
+    "DataTypeSpec": "datatypes",
     "EngineSpec": "engine_spec",
     "EngineProviderSpec": "engine_spec",
+    "EngineDatatypeBridge": "datatypes",
+    "EngineRegistry": "datatypes",
+    "EngineTypeLowerer": "datatypes",
     "FieldSpec": "field_spec",
     "F": "field_spec",
+    "BaseTypeAdapter": "datatypes",
     "HookSpec": "hook_spec",
     "IOSpec": "io_spec",
     "IO": "io_spec",
+    "ReflectedDatatype": "datatypes",
+    "ReflectedTypeMapper": "datatypes",
+    "StaticEngineLowerer": "datatypes",
+    "as_tuple": "monotone",
     "MiddlewareSpec": "middleware_spec",
+    "highest_precedence": "monotone",
+    "keyed_overlay": "monotone",
+    "mapping_overlay": "monotone",
+    "merge_mro_mapping_attr": "monotone",
+    "merge_mro_sequence_attr": "monotone",
     "OpSpec": "op_spec",
+    "sequence_union": "monotone",
+    "stable_keyed_overlay": "monotone",
+    "stable_unique": "monotone",
     "Arity": "op_spec",
     "TargetOp": "op_spec",
     "PersistPolicy": "op_spec",
+    "TxScope": "op_spec",
     "PHASE": "op_spec",
     "PHASES": "op_spec",
     "HookPhase": "hook_spec",
@@ -48,11 +72,14 @@ _EXPORTS = {
     "tx_repeatable_read": "session_spec",
     "tx_serializable": "session_spec",
     "readonly": "session_spec",
+    "StorageTypeRef": "datatypes",
     "StorageSpec": "storage_spec",
     "S": "storage_spec",
     "StorageTransformSpec": "storage_spec",
     "StorageTransform": "storage_spec",
     "ForeignKeySpec": "storage_spec",
+    "TypeAdapter": "datatypes",
+    "TypeRegistry": "datatypes",
     "TableSpec": "table_spec",
     "TableRegistrySpec": "table_registry_spec",
 }

{tigrbl_core-0.1.0.dev15 → tigrbl_core-0.1.11.dev1}/tigrbl_core/_spec/app_spec.py

@@ -1,9 +1,10 @@
 # pkgs/standards/tigrbl_core/tigrbl/_spec/app_spec.py
 from __future__ import annotations
 from dataclasses import dataclass, field
-from typing import Any, Callable, Iterable, Mapping, Optional, Sequence
+from typing import Any, Callable, Optional, Sequence
 
 from .._spec.engine_spec import EngineCfg
+from .._spec.monotone import as_tuple, merge_mro_sequence_attr
 from .._spec.response_spec import ResponseSpec
 from .serde import SerdeMixin
 
@@ -11,17 +12,7 @@ from .serde import SerdeMixin
 def _seqify(value: Any) -> tuple[Any, ...]:
     """Normalize sequence-like inputs while treating scalars as a single item."""
 
-    if value is None:
-        return ()
-    if isinstance(value, tuple):
-        return value
-    if isinstance(value, (str, bytes, bytearray)):
-        return (value,)
-    if isinstance(value, Mapping):
-        return (value,)
-    if isinstance(value, Iterable):
-        return tuple(value)
-    return (value,)
+    return as_tuple(value)
 
 
 def merge_seq_attr(
@@ -34,27 +25,13 @@ def merge_seq_attr(
 ) -> tuple[Any, ...]:
     """Merge sequence-like class attributes over the MRO."""
 
-    values: list[Any] = []
-    seen_hashable: set[Any] = set()
-    mro = reversed(owner.__mro__) if reverse else owner.__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 ()
-        for item in _seqify(seq):
-            if dedupe:
-                try:
-                    if item in seen_hashable:
-                        continue
-                    seen_hashable.add(item)
-                except TypeError:
-                    if any(item == existing for existing in values):
-                        continue
-            values.append(item)
-    return tuple(values)
+    return merge_mro_sequence_attr(
+        owner,
+        attr,
+        include_inherited=include_inherited,
+        reverse=reverse,
+        dedupe=dedupe,
+    )
 
 
 def normalize_app_spec(spec: "AppSpec") -> "AppSpec":
@@ -68,6 +45,7 @@ def normalize_app_spec(spec: "AppSpec") -> "AppSpec":
         title=str(spec.title or "Tigrbl"),
         description=spec.description,
         version=str(spec.version or "0.1.0"),
+        execution_backend=str(getattr(spec, "execution_backend", None) or "auto"),
         engine=spec.engine,
         routers=routers,
         ops=ops,
@@ -93,6 +71,7 @@ class AppSpec(SerdeMixin):
     title: str = "Tigrbl"
     description: str | None = None
     version: str = "0.1.0"
+    execution_backend: str = "auto"
     engine: Optional[EngineCfg] = None
 
     # NEW: multi-Router composition (store Router classes or instances)
@@ -128,6 +107,7 @@ class AppSpec(SerdeMixin):
         sentinel = object()
         title: Any = sentinel
         version: Any = sentinel
+        execution_backend: Any = sentinel
         engine: Any | None = sentinel  # type: ignore[assignment]
         response: Any = sentinel
         jsonrpc_prefix: Any = sentinel
@@ -139,6 +119,11 @@ class AppSpec(SerdeMixin):
                 title = base.__dict__["TITLE"]
             if "VERSION" in base.__dict__ and version is sentinel:
                 version = base.__dict__["VERSION"]
+            if (
+                "EXECUTION_BACKEND" in base.__dict__
+                and execution_backend is sentinel
+            ):
+                execution_backend = base.__dict__["EXECUTION_BACKEND"]
             if "ENGINE" in base.__dict__ and engine is sentinel:
                 engine = base.__dict__["ENGINE"]
             if "RESPONSE" in base.__dict__ and response is sentinel:
@@ -154,6 +139,8 @@ class AppSpec(SerdeMixin):
             title = "Tigrbl"
         if version is sentinel:
             version = "0.1.0"
+        if execution_backend is sentinel:
+            execution_backend = "auto"
         if engine is sentinel:
             engine = None
         if response is sentinel:
@@ -171,6 +158,7 @@ class AppSpec(SerdeMixin):
             title=title,
             description=description,
             version=version,
+            execution_backend=execution_backend,
             engine=engine,
             routers=tuple(
                 merge_seq_attr(
@@ -199,6 +187,7 @@ class AppSpec(SerdeMixin):
                 title=spec.title,
                 description=spec.description,
                 version=spec.version,
+                execution_backend=spec.execution_backend,
                 engine=spec.engine,
                 routers=tuple(spec.routers or ()),
                 ops=tuple(spec.ops or ()),

{tigrbl_core-0.1.0.dev15 → tigrbl_core-0.1.11.dev1}/tigrbl_core/_spec/binding_spec.py

@@ -3,21 +3,58 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Literal, Optional, Type, Union
 
-from ..config.constants import TIGRBL_NESTED_PATHS_ATTR
+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)
@@ -25,12 +62,25 @@ 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,
 ]
 
 
@@ -70,9 +120,14 @@ def resolve_rest_nested_prefix(model: Type) -> Optional[str]:
 __all__ = [
     "BindingSpec",
     "BindingRegistrySpec",
+    "Exchange",
+    "Framing",
     "HttpJsonRpcBindingSpec",
     "HttpRestBindingSpec",
+    "HttpStreamBindingSpec",
+    "SseBindingSpec",
     "TransportBindingSpec",
+    "WebTransportBindingSpec",
     "WsBindingSpec",
     "resolve_rest_nested_prefix",
 ]

{tigrbl_core-0.1.0.dev15 → tigrbl_core-0.1.11.dev1}/tigrbl_core/_spec/column_spec.py

@@ -5,9 +5,10 @@ from functools import lru_cache
 from types import SimpleNamespace
 from typing import Any, Callable, Dict, Optional
 
+from .datatypes import DataTypeSpec, StorageTypeRef, infer_datatype
 from .._spec.field_spec import FieldSpec as F
 from .._spec.io_spec import IOSpec as IO
-from .._spec.storage_spec import StorageSpec as S
+from .._spec.storage_spec import ForeignKeySpec, StorageSpec as S
 from .serde import SerdeMixin
 
 logger = logging.getLogger("uvicorn")
@@ -34,6 +35,7 @@ class ColumnSpec(SerdeMixin):
         self,
         *,
         storage: S | None,
+        datatype: DataTypeSpec | None = None,
         field: F | None = None,
         io: IO | None = None,
         default_factory: Optional[Callable[[dict], Any]] = None,
@@ -42,6 +44,12 @@ class ColumnSpec(SerdeMixin):
         self.storage = storage
         self.field = field if field is not None else F()
         self.io = io if io is not None else IO()
+        self.datatype = datatype or infer_datatype(
+            field_py_type=self.field.py_type,
+            storage_type=getattr(storage, "type_", None),
+            nullable=getattr(storage, "nullable", None),
+            constraints=getattr(self.field, "constraints", {}),
+        )
         self.default_factory = default_factory
         self.read_producer = read_producer
 
@@ -85,6 +93,49 @@ class ColumnSpec(SerdeMixin):
         except TypeError:
             return ()
 
+    @staticmethod
+    def _storage_spec_from_column(column: object) -> S:
+        fk_spec = None
+        foreign_keys = tuple(getattr(column, "foreign_keys", ()) or ())
+        if foreign_keys:
+            fk = foreign_keys[0]
+            target = str(getattr(fk, "target_fullname", "") or "")
+            if target:
+                fk_spec = ForeignKeySpec(
+                    target=target,
+                    on_delete=str(getattr(fk, "ondelete", None) or "RESTRICT"),
+                    on_update=str(getattr(fk, "onupdate", None) or "RESTRICT"),
+                    deferrable=bool(getattr(fk, "deferrable", False)),
+                    initially_deferred=(
+                        str(getattr(fk, "initially", "") or "").upper() == "DEFERRED"
+                    ),
+                    match=str(getattr(fk, "match", None) or "SIMPLE"),
+                )
+
+        type_obj = getattr(column, "type", None)
+        physical_name = None
+        if type_obj is not None:
+            physical_name = getattr(type_obj, "__visit_name__", None) or type(type_obj).__name__
+
+        return S(
+            type_=type_obj,
+            physical_type=(
+                StorageTypeRef(physical_name=str(physical_name))
+                if physical_name is not None
+                else None
+            ),
+            nullable=getattr(column, "nullable", None),
+            unique=bool(getattr(column, "unique", False)),
+            index=bool(getattr(column, "index", False)),
+            primary_key=bool(getattr(column, "primary_key", False)),
+            autoincrement=getattr(column, "autoincrement", None),
+            default=getattr(getattr(column, "default", None), "arg", None),
+            onupdate=getattr(getattr(column, "onupdate", None), "arg", None),
+            server_default=getattr(getattr(column, "server_default", None), "arg", None),
+            fk=fk_spec,
+            comment=getattr(column, "comment", None),
+        )
+
     @staticmethod
     @lru_cache(maxsize=None)
     def _mro_collect_columns_cached(
@@ -121,7 +172,13 @@ class ColumnSpec(SerdeMixin):
                 name = getattr(col, "key", None) or getattr(col, "name", None)
                 if not isinstance(name, str):
                     continue
-                out.setdefault(name, ColumnSpec(storage=S(), io=ColumnSpec._DEFAULT_IO))
+                out.setdefault(
+                    name,
+                    ColumnSpec(
+                        storage=ColumnSpec._storage_spec_from_column(col),
+                        io=ColumnSpec._DEFAULT_IO,
+                    ),
+                )
         else:
             # Declarative models can be inspected before SQLAlchemy finishes
             # materializing ``__table__``. In that transient state plain
@@ -133,7 +190,8 @@ class ColumnSpec(SerdeMixin):
                         continue
                     if hasattr(value, "type") and hasattr(value, "nullable"):
                         out[attr_name] = ColumnSpec(
-                            storage=S(), io=ColumnSpec._DEFAULT_IO
+                            storage=ColumnSpec._storage_spec_from_column(value),
+                            io=ColumnSpec._DEFAULT_IO,
                         )
 
         logger.debug(