vention-communication 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

communication/app.py

@@ -7,6 +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 .rpc_registry import RpcRegistry
 
 
 class VentionApp(FastAPI):
@@ -35,9 +36,11 @@ class VentionApp(FastAPI):
         self.name = name
         self.emit_proto = emit_proto
         self.proto_path = proto_path
-        self.connect_router = ConnectRouter()
+
         self._extra_bundles: List[RpcBundle] = []
 
+        self._registry = RpcRegistry(service_name=self.service_name)
+
     def register_rpc_plugin(self, bundle: RpcBundle) -> None:
         """Add RPCs/streams provided by external libraries.
 
@@ -51,30 +54,41 @@ class VentionApp(FastAPI):
     def finalize(self) -> None:
         """Finalize the app by registering all RPCs and streams.
 
-        Collects decorator-registered RPCs, merges external bundles,
-        registers them with the Connect router, optionally emits proto
-        definitions, and makes the app available to stream publishers.
+        Steps:
+        - Collect decorator-registered RPCs
+        - Merge in external bundles
+        - Use RpcRegistry to:
+            * apply aliases to all Pydantic models
+            * provide a unified RpcBundle
+        - Wire actions/streams into ConnectRouter
+        - Mount router at /rpc
+        - Optionally generate .proto
+        - Expose global app for stream publishers
         """
-        bundle = collect_bundle()
+        base_bundle = collect_bundle()
+        self._registry.add_bundle(base_bundle)
         for extra_bundle in self._extra_bundles:
-            bundle.extend(extra_bundle)
+            self._registry.add_bundle(extra_bundle)
 
-        service_fully_qualified_name = f"vention.app.v1.{self.service_name}Service"
+        unified_bundle = self._registry.get_unified_bundle()
+
+        service_full_name = f"vention.app.v1.{self.service_name}Service"
+        self.connect_router = ConnectRouter()
 
-        for action_entry in bundle.actions:
-            self.connect_router.add_unary(action_entry, service_fully_qualified_name)
-        for stream_entry in bundle.streams:
-            self.connect_router.add_stream(stream_entry, service_fully_qualified_name)
+        for action_entry in unified_bundle.actions:
+            self.connect_router.add_unary(action_entry, service_full_name)
+        for stream_entry in unified_bundle.streams:
+            self.connect_router.add_stream(stream_entry, service_full_name)
 
         self.include_router(self.connect_router.router, prefix="/rpc")
 
         if self.emit_proto:
-            proto = generate_proto(self.service_name, bundle=bundle)
+            proto_text = generate_proto(self.service_name, bundle=unified_bundle)
             import os
 
             os.makedirs(os.path.dirname(self.proto_path), exist_ok=True)
-            with open(self.proto_path, "w", encoding="utf-8") as proto_file:
-                proto_file.write(proto)
+            with open(self.proto_path, "w", encoding="utf-8") as f:
+                f.write(proto_text)
 
         set_global_app(self)
 

communication/codegen.py

@@ -6,7 +6,7 @@ from .typing_utils import is_pydantic_model
 from .entries import RpcBundle, StreamEntry
 
 _SCALAR_MAP = {
-    int: "int64",
+    int: "int32",
     float: "double",
     str: "string",
     bool: "bool",

communication/connect_router.py

@@ -217,7 +217,7 @@ class ConnectRouter:
                     result = await _maybe_await(entry.func(validated_arg))
 
                 if hasattr(result, "model_dump"):
-                    result = result.model_dump()
+                    result = result.model_dump(by_alias=True)
                 return JSONResponse(result or {})
             except Exception as exc:
                 return JSONResponse(error_envelope(exc))
@@ -283,7 +283,7 @@ class ConnectRouter:
 
 def _serialize_stream_item(item: Any) -> Dict[str, Any]:
     if hasattr(item, "model_dump"):
-        dumped = item.model_dump()
+        dumped = item.model_dump(by_alias=True)
         if isinstance(dumped, dict):
             return dumped
         return {"value": dumped}

communication/registry.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, List, Optional, Set, Type, get_args, get_origin, Union
+
+from pydantic import BaseModel
+
+from .entries import RpcBundle
+from .typing_utils import 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_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.
+
+        After this runs, nothing else in the system should call apply_aliases_to_model().
+        """
+        if self._models_normalized:
+            return
+
+        seen: Set[Type[BaseModel]] = set()
+
+        def _extract_nested_models(field_type: Any) -> List[Type[BaseModel]]:
+            """Extract Pydantic models from a field type, handling Optional, List, etc."""
+            nested: List[Type[BaseModel]] = []
+
+            # Handle Optional[Type] -> Union[Type, None]
+            origin = get_origin(field_type)
+            if origin is Union:
+                args = get_args(field_type)
+                # Filter out None type
+                non_none_args = [arg for arg in args if arg is not type(None)]
+                if len(non_none_args) == 1:
+                    field_type = non_none_args[0]
+                    origin = get_origin(field_type)
+
+            # Handle List[Type]
+            if origin in (list, List):
+                args = get_args(field_type)
+                if args:
+                    field_type = args[0]
+                    origin = get_origin(field_type)
+                    # Handle Optional inside List
+                    if origin is Union:
+                        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:
+                            field_type = non_none_args[0]
+
+            # Check if the final type is a Pydantic model
+            if is_pydantic_model(field_type):
+                nested.append(field_type)
+
+            return nested
+
+        def normalize_model(model: Optional[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)
+
+            # Recursively normalize nested models
+            if hasattr(model, "model_fields"):
+                for field_name, field_info in model.model_fields.items():
+                    nested_models = _extract_nested_models(field_info.annotation)
+                    for nested_model in nested_models:
+                        normalize_model(nested_model)
+
+        for bundle in self._bundles:
+            for action in bundle.actions:
+                normalize_model(action.input_type)
+                normalize_model(action.output_type)
+            for stream in bundle.streams:
+                normalize_model(stream.payload_type)
+
+        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

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

communication/typing_utils.py

@@ -1,8 +1,19 @@
 from __future__ import annotations
 import inspect
-from typing import Any, Optional, Type, get_type_hints, cast
-
-from pydantic import BaseModel
+from typing import (
+    Any,
+    Callable,
+    List,
+    Optional,
+    Type,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+    cast,
+)
+
+from pydantic import BaseModel, ConfigDict
 
 
 class TypingError(Exception):
@@ -18,7 +29,7 @@ def _strip_self(params: list[inspect.Parameter]) -> list[inspect.Parameter]:
     return params
 
 
-def infer_input_type(function: Any) -> Optional[Type[Any]]:
+def infer_input_type(function: Callable[..., Any]) -> Optional[Type[Any]]:
     """Infer the input type annotation from a function's first parameter.
 
     Args:
@@ -50,7 +61,7 @@ def infer_input_type(function: Any) -> Optional[Type[Any]]:
     return None
 
 
-def infer_output_type(function: Any) -> Optional[Type[Any]]:
+def infer_output_type(function: Callable[..., Any]) -> Optional[Type[Any]]:
     """Infer the return type annotation from a function.
 
     Args:
@@ -88,3 +99,74 @@ def is_pydantic_model(type_annotation: Any) -> bool:
         )
     except Exception:
         return False
+
+
+def camelize(name: str) -> str:
+    parts = name.split("_")
+    return parts[0] + "".join(p.capitalize() for p in parts[1:])
+
+
+def apply_aliases(model_cls: Type[BaseModel]) -> None:
+    fields = model_cls.model_fields
+
+    for name, field in fields.items():
+        alias = camelize(name)
+
+        field.alias = alias
+        field.validation_alias = alias
+
+    # Ensure Pydantic accepts both snake_case and camelCase
+    existing_config = getattr(model_cls, "model_config", None)
+    if existing_config is None:
+        existing_dict: dict[str, Any] = {}
+    else:
+        existing_dict = (
+            dict(existing_config) if isinstance(existing_config, dict) else {}
+        )
+
+    merged_config: dict[str, Any] = {
+        "populate_by_name": True,
+        "from_attributes": True,
+        **existing_dict,
+    }
+    model_cls.model_config = cast(ConfigDict, merged_config)
+
+    # 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 []

{vention_communication-0.2.1.dist-info → vention_communication-0.3.0.dist-info}/METADATA

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

vention_communication-0.3.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+communication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+communication/app.py,sha256=dxbm7oG8-uQSu_dY4S8exHsBXND1N1nC2GdsMthqZE0,3423
+communication/codegen.py,sha256=_1LYma-MXedwRHn_P3CqPs1xIMEZrZgiUAsGSj9yff4,7089
+communication/connect_router.py,sha256=tjNl9dRukjLecZH1y-GYIQXH-0xzz9JESbikSH5XhFo,10527
+communication/decorators.py,sha256=3pVlXUSX4KXSKlweskF0RfD8pST2zisTuFGJQHHIvcI,3419
+communication/entries.py,sha256=vdZc8GAQztRWEiav6R2wM4l35GE-EiEdRH0ZJR4GShM,1065
+communication/errors.py,sha256=hdJBB9jPJNWx8hbxIxwLBNKt2JVpmhZ1YF8q9VKk-dI,1773
+communication/registry.py,sha256=acbhwU0z1iRHqzOahXG47GfJS5VQHjf69UiruoXrr7g,4517
+communication/rpc_registry.py,sha256=90r4YYHKveVGBO-pOD91qAs9GSB3651WPclC6oRnrZo,2986
+communication/typing_utils.py,sha256=6S6LvtjFBZKo-gWPc8fbh4F1rlPWFgrH_mX8esZbzWM,4559
+vention_communication-0.3.0.dist-info/METADATA,sha256=e6h67l5DGs9LSAL_eBan_spH60FDQfBVcmeyoNWrlvg,11255
+vention_communication-0.3.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+vention_communication-0.3.0.dist-info/RECORD,,

vention_communication-0.2.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-communication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-communication/app.py,sha256=9syaxfb8HJa3x_WBWa3ZRKClBFbaOZkSL_D6L0ZwIfI,3030
-communication/codegen.py,sha256=SwCIYptjmCbnFGPl0zZ0Ahj4UP27xpy7ELftQurMANM,7089
-communication/connect_router.py,sha256=uwFmMKdvVUC0dwepXCTvWcERQV2QlGD1xdTkIHCYl5k,10501
-communication/decorators.py,sha256=3pVlXUSX4KXSKlweskF0RfD8pST2zisTuFGJQHHIvcI,3419
-communication/entries.py,sha256=vdZc8GAQztRWEiav6R2wM4l35GE-EiEdRH0ZJR4GShM,1065
-communication/errors.py,sha256=hdJBB9jPJNWx8hbxIxwLBNKt2JVpmhZ1YF8q9VKk-dI,1773
-communication/typing_utils.py,sha256=M_q_2fKjEG8t2de5nzmHH55CmsGtTNYbKI_AlKkFUN8,2399
-vention_communication-0.2.1.dist-info/METADATA,sha256=380w8HHpQ5GYu23fJcAob7RIRGNOWPNEJt_9kGSCQ1M,11255
-vention_communication-0.2.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-vention_communication-0.2.1.dist-info/RECORD,,