tigrbl 0.3.3.dev2__tar.gz → 0.3.4.dev1__tar.gz

{tigrbl-0.3.3.dev2 → tigrbl-0.3.4.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl
-Version: 0.3.3.dev2
+Version: 0.3.4.dev1
 Summary: Automatic API generation tools by Swarmauri.
 License-Expression: Apache-2.0
 License-File: LICENSE

{tigrbl-0.3.3.dev2 → tigrbl-0.3.4.dev1}/pyproject.toml

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

{tigrbl-0.3.3.dev2 → tigrbl-0.3.4.dev1}/tigrbl/deps/__init__.py

@@ -16,5 +16,5 @@ from .pydantic import *  # noqa: F403, F401
 # Re-export all FastAPI dependencies
 from .fastapi import *  # noqa: F403, F401
 
-# Note: starlette.py is reserved for future Starlette-specific imports
-# if we need to import directly from Starlette rather than through FastAPI
+# Re-export Starlette dependencies (Request/Response live here)
+from .starlette import *  # noqa: F403, F401

{tigrbl-0.3.3.dev2 → tigrbl-0.3.4.dev1}/tigrbl/deps/fastapi.py

@@ -4,8 +4,6 @@ from fastapi import (
     FastAPI,
     Security,
     Depends,
-    Request,
-    Response,
     Path as FastAPIPath,
     Body,
     HTTPException,
@@ -36,8 +34,6 @@ __all__ = [
     "FastAPI",
     "Security",
     "Depends",
-    "Request",
-    "Response",
     "Path",
     "Body",
     "HTTPException",

{tigrbl-0.3.3.dev2 → tigrbl-0.3.4.dev1}/tigrbl/runtime/executor/types.py

@@ -8,23 +8,17 @@ from typing import (
     Mapping,
     MutableMapping,
     Optional,
+    Protocol,
     Sequence,
     Union,
-    Protocol,
     runtime_checkable,
 )
 
-try:
-    from fastapi import Request  # type: ignore
-except Exception:  # pragma: no cover
-    Request = Any  # type: ignore
+from ...deps.starlette import Request as StarletteRequest
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session
 
-try:
-    from sqlalchemy.orm import Session  # type: ignore
-    from sqlalchemy.ext.asyncio import AsyncSession  # type: ignore
-except Exception:  # pragma: no cover
-    Session = Any  # type: ignore
-    AsyncSession = Any  # type: ignore
+Request = StarletteRequest if StarletteRequest is not None else Any  # type: ignore
 
 
 @runtime_checkable

{tigrbl-0.3.3.dev2 → tigrbl-0.3.4.dev1}/tigrbl/transport/__init__.py

@@ -27,7 +27,7 @@ from __future__ import annotations
 from typing import Any, Callable, Optional, Sequence
 
 # JSON-RPC transport
-from .jsonrpc import build_jsonrpc_router
+from .jsonrpc import build_jsonrpc_router, build_openrpc_spec
 
 # REST transport (aggregator over per-model routers)
 from .rest import build_rest_router, mount_rest
@@ -67,6 +67,7 @@ def mount_jsonrpc(
 __all__ = [
     # JSON-RPC
     "build_jsonrpc_router",
+    "build_openrpc_spec",
     "mount_jsonrpc",
     # REST
     "build_rest_router",

{tigrbl-0.3.3.dev2 → tigrbl-0.3.4.dev1}/tigrbl/transport/jsonrpc/__init__.py

@@ -6,14 +6,18 @@ Public helper:
   - build_jsonrpc_router(
         api, *, get_db=None, tags=("rpc",)
     ) -> Router
+  - build_openrpc_spec(api) -> dict
 
 Usage:
     from tigrbl.transport.jsonrpc import build_jsonrpc_router
     app.include_router(build_jsonrpc_router(api), prefix="/rpc")
+    # OpenRPC schema (JSON-RPC equivalent of OpenAPI)
+    build_openrpc_spec(api)
 """
 
 from __future__ import annotations
 
 from .dispatcher import build_jsonrpc_router
+from .openrpc import build_openrpc_spec
 
-__all__ = ["build_jsonrpc_router"]
+__all__ = ["build_jsonrpc_router", "build_openrpc_spec"]

{tigrbl-0.3.3.dev2 → tigrbl-0.3.4.dev1}/tigrbl/transport/jsonrpc/dispatcher.py

@@ -78,6 +78,7 @@ except Exception:  # pragma: no cover
 from ...runtime.errors import ERROR_MESSAGES, http_exc_to_rpc
 from ...config.constants import TIGRBL_AUTH_CONTEXT_ATTR
 from .models import RPCRequest, RPCResponse
+from .openrpc import build_openrpc_spec
 from .helpers import (
     _authorize,
     _err,
@@ -337,6 +338,19 @@ def build_jsonrpc_router(
         # extra router deps already applied via Router(dependencies=...)
     )
 
+    def _openrpc_endpoint():
+        return build_openrpc_spec(api)
+
+    router.add_api_route(
+        path="/openrpc.json",
+        endpoint=_openrpc_endpoint,
+        methods=["GET"],
+        name="openrpc_json",
+        tags=list(tags) if tags else None,
+        summary="OpenRPC",
+        description="OpenRPC 1.2.6 schema for JSON-RPC methods.",
+    )
+
     # Compatibility: serve same endpoint without trailing slash
     router.add_api_route(
         path="/",

tigrbl-0.3.4.dev1/tigrbl/transport/jsonrpc/openrpc.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, List, Mapping, Sequence
+
+from pydantic import BaseModel
+
+from ...op import OpSpec
+
+JsonObject = Dict[str, Any]
+
+
+def _iter_models(api: Any) -> List[type]:
+    seen: set[type] = set()
+    models: List[type] = []
+
+    def _add_from(container: Any) -> None:
+        if isinstance(container, Mapping):
+            items: Iterable[Any] = container.values()
+        elif isinstance(container, Sequence):
+            items = container
+        else:
+            return
+        for model in items:
+            if isinstance(model, type) and model not in seen:
+                seen.add(model)
+                models.append(model)
+
+    _add_from(getattr(api, "models", None) or {})
+    for child in getattr(api, "apis", ()) or ():
+        _add_from(getattr(child, "models", None) or {})
+
+    return models
+
+
+def _iter_ops(model: type) -> Sequence[OpSpec]:
+    ops = getattr(model, "ops", None)
+    if ops is not None:
+        all_ops = getattr(ops, "all", None)
+        if all_ops is not None:
+            return all_ops
+    opspecs = getattr(model, "opspecs", None)
+    if opspecs is not None:
+        all_ops = getattr(opspecs, "all", None)
+        if all_ops is not None:
+            return all_ops
+    return ()
+
+
+def _schema_with_defs(schema: type[BaseModel]) -> tuple[JsonObject, JsonObject]:
+    raw = schema.model_json_schema(ref_template="#/components/schemas/{model}")
+    defs = raw.pop("$defs", {})
+    return raw, defs
+
+
+def _describe_method(model: type, spec: OpSpec) -> str | None:
+    rpc_ns = getattr(model, "rpc", None)
+    rpc_call = getattr(rpc_ns, spec.alias, None)
+    if rpc_call is None:
+        return None
+    doc = getattr(rpc_call, "__doc__", None)
+    if doc:
+        return doc.strip()
+    return None
+
+
+def build_openrpc_spec(api: Any) -> JsonObject:
+    info_title = getattr(api, "title", None) or getattr(api, "name", None) or "API"
+    info_version = getattr(api, "version", None) or "0.1.0"
+    spec: JsonObject = {
+        "openrpc": "1.2.6",
+        "info": {"title": f"{info_title} JSON-RPC API", "version": info_version},
+        "methods": [],
+        "components": {"schemas": {}},
+    }
+
+    components = spec["components"]["schemas"]
+    methods: List[JsonObject] = []
+
+    for model in _iter_models(api):
+        for op in _iter_ops(model):
+            if not getattr(op, "expose_rpc", True):
+                continue
+
+            method: JsonObject = {"name": f"{model.__name__}.{op.alias}"}
+            description = _describe_method(model, op)
+            if description:
+                method["description"] = description
+
+            alias_ns = getattr(getattr(model, "schemas", None), op.alias, None)
+            in_schema = getattr(alias_ns, "in_", None)
+            out_schema = getattr(alias_ns, "out", None)
+
+            if in_schema is not None:
+                in_json, defs = _schema_with_defs(in_schema)
+                for key, value in defs.items():
+                    components.setdefault(key, value)
+                method["params"] = [
+                    {"name": "params", "schema": in_json, "required": True}
+                ]
+                method["paramStructure"] = "by-name"
+            else:
+                method["params"] = []
+
+            if out_schema is not None:
+                out_json, defs = _schema_with_defs(out_schema)
+                for key, value in defs.items():
+                    components.setdefault(key, value)
+                method["result"] = {"name": "result", "schema": out_json}
+
+            methods.append(method)
+
+    spec["methods"] = sorted(methods, key=lambda item: item["name"])
+    return spec
+
+
+__all__ = ["build_openrpc_spec"]

{tigrbl-0.3.3.dev2 → tigrbl-0.3.4.dev1}/tigrbl/types/__init__.py

@@ -57,13 +57,12 @@ from ..deps.fastapi import (
     Router,
     Security,
     Depends,
-    Request,
-    Response,
     Path,
     Body,
     HTTPException,
     App,
 )
+from ..deps.starlette import Request, Response
 
 # ── Local Package ─────────────────────────────────────────────────────────
 from .op import _Op, _SchemaVerb

{tigrbl-0.3.3.dev2 → tigrbl-0.3.4.dev1}/tigrbl/types/authn_abc.py

@@ -1,7 +1,8 @@
 # tigrbl/v3/types/authn_abc.py
 from __future__ import annotations
 from abc import ABC, abstractmethod
-from fastapi import Request
+
+from ..deps.starlette import Request
 
 
 class AuthNProvider(ABC):