vention-communication 0.2.2__tar.gz → 0.3.0__tar.gz

{vention_communication-0.2.2 → vention_communication-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vention-communication
-Version: 0.2.2
+Version: 0.3.0
 Summary: A framework for communication between machine apps and other services.
 License: Proprietary
 Author: VentionCo

{vention_communication-0.2.2 → vention_communication-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vention-communication"
-version = "0.2.2"
+version = "0.3.0"
 description = "A framework for communication between machine apps and other services."
 authors = [ "VentionCo" ]
 readme = "README.md"

{vention_communication-0.2.2 → vention_communication-0.3.0}/src/communication/app.py

@@ -7,7 +7,7 @@ from .connect_router import ConnectRouter
 from .decorators import collect_bundle, set_global_app
 from .codegen import generate_proto, sanitize_service_name
 from .entries import RpcBundle
-from .registry import RpcRegistry
+from .rpc_registry import RpcRegistry
 
 
 class VentionApp(FastAPI):

vention_communication-0.3.0/src/communication/rpc_registry.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Set, Type
+
+from pydantic import BaseModel
+
+from .entries import RpcBundle
+from .typing_utils import extract_nested_models, is_pydantic_model, apply_aliases
+
+
+@dataclass
+class RpcRegistry:
+    """
+    Central registry that collects RPC bundles, applies model normalization
+    (Pydantic field aliasing), and exposes a unified bundle.
+
+    - Plugins and decorators add RpcBundle instances.
+    - Registry merges them.
+    - Registry applies camelCase aliases to all Pydantic models exactly once.
+    """
+
+    service_name: str = "VentionApp"
+    _bundles: List[RpcBundle] = field(default_factory=list)
+    _models_normalized: bool = False
+
+    # ------------- Bundle registration -------------
+
+    def add_bundle(self, bundle: RpcBundle) -> None:
+        """Register a bundle for inclusion in the unified RPC view."""
+        self._bundles.append(bundle)
+
+    @property
+    def bundle(self) -> RpcBundle:
+        """Return a merged RpcBundle (does not mutate stored bundles)."""
+        merged = RpcBundle()
+        for bundle in self._bundles:
+            merged.extend(bundle)
+        return merged
+
+    # ------------- Model normalization / aliasing -------------
+    def _normalize_model(
+        self, model: Optional[Type[BaseModel]], seen: Set[Type[BaseModel]]
+    ) -> None:
+        """Recursively normalize a model and all its nested models."""
+        if model is None:
+            return
+        if not is_pydantic_model(model):
+            return
+        if model in seen:
+            return
+
+        seen.add(model)
+        apply_aliases(model)
+
+        if hasattr(model, "model_fields"):
+            for _, field_info in model.model_fields.items():
+                nested_models = extract_nested_models(field_info.annotation)
+                for nested_model in nested_models:
+                    self._normalize_model(nested_model, seen)
+
+    def normalize_models_and_apply_aliases(self) -> None:
+        """
+        Walk all RPCs in all bundles and apply camelCase JSON aliases
+        to every Pydantic model exactly once, including nested models.
+        """
+        if self._models_normalized:
+            return
+
+        seen: Set[Type[BaseModel]] = set()
+
+        for bundle in self._bundles:
+            for action in bundle.actions:
+                self._normalize_model(action.input_type, seen)
+                self._normalize_model(action.output_type, seen)
+            for stream in bundle.streams:
+                self._normalize_model(stream.payload_type, seen)
+
+        self._models_normalized = True
+
+    # ------------- Unified, normalized view -------------
+
+    def get_unified_bundle(self) -> RpcBundle:
+        """
+        Get the fully merged, normalized RPC bundle.
+
+        This will apply aliasing exactly once and then return a merged RpcBundle.
+        """
+        self.normalize_models_and_apply_aliases()
+        return self.bundle

{vention_communication-0.2.2 → vention_communication-0.3.0}/src/communication/typing_utils.py

@@ -1,6 +1,17 @@
 from __future__ import annotations
 import inspect
-from typing import Any, Callable, Optional, Type, get_type_hints, cast
+from typing import (
+    Any,
+    Callable,
+    List,
+    Optional,
+    Type,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+    cast,
+)
 
 from pydantic import BaseModel, ConfigDict
 
@@ -122,3 +133,40 @@ def apply_aliases(model_cls: Type[BaseModel]) -> None:
 
     # Force rebuild
     model_cls.model_rebuild(force=True)
+
+
+def unwrap_optional(field_type: Any) -> Any:
+    """Unwrap Optional[Type] or Union[Type, None] to get the non-None type."""
+    origin = get_origin(field_type)
+    if origin is not Union:
+        return field_type
+
+    args = get_args(field_type)
+    non_none_args = [arg for arg in args if arg is not type(None)]
+    if len(non_none_args) == 1:
+        return non_none_args[0]
+    return field_type
+
+
+def unwrap_list(field_type: Any) -> Any:
+    """Unwrap List[Type] to get the inner type, handling Optional inside List."""
+    origin = get_origin(field_type)
+    if origin not in (list, List):
+        return field_type
+
+    args = get_args(field_type)
+    if not args:
+        return field_type
+
+    inner_type = args[0]
+    return unwrap_optional(inner_type)
+
+
+def extract_nested_models(field_type: Any) -> List[Type[BaseModel]]:
+    """Extract Pydantic models from a field type, handling Optional, List, etc."""
+    field_type = unwrap_optional(field_type)
+    field_type = unwrap_list(field_type)
+
+    if is_pydantic_model(field_type):
+        return [field_type]
+    return []