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

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

@@ -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.2.1 → vention_communication-0.3.0}/pyproject.toml

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

{vention_communication-0.2.1 → vention_communication-0.3.0}/src/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)
 

{vention_communication-0.2.1 → vention_communication-0.3.0}/src/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",

{vention_communication-0.2.1 → vention_communication-0.3.0}/src/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}

vention_communication-0.3.0/src/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

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.3.0/src/communication/typing_utils.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+import inspect
+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):
+    """Raised when type inference fails."""
+
+
+def _strip_self(params: list[inspect.Parameter]) -> list[inspect.Parameter]:
+    if not params:
+        return params
+    first = params[0]
+    if first.name in ("self", "cls"):
+        return params[1:]
+    return params
+
+
+def infer_input_type(function: Callable[..., Any]) -> Optional[Type[Any]]:
+    """Infer the input type annotation from a function's first parameter.
+
+    Args:
+        function: Function to inspect
+
+    Returns:
+        Type annotation of the first parameter, or None if no parameters or type is Any
+
+    Raises:
+        TypingError: If the first parameter lacks a type annotation
+    """
+    signature = inspect.signature(function)
+    parameters = _strip_self(list(signature.parameters.values()))
+    if not parameters:
+        return None
+
+    first_param = parameters[0]
+    type_hints = get_type_hints(function)
+    if first_param.name not in type_hints:
+        raise TypingError(f"First parameter '{first_param.name}' must be annotated")
+
+    hint_type = type_hints[first_param.name]
+    if hint_type is Any:
+        return None
+
+    if isinstance(hint_type, type):
+        return cast(Type[Any], hint_type)
+
+    return None
+
+
+def infer_output_type(function: Callable[..., Any]) -> Optional[Type[Any]]:
+    """Infer the return type annotation from a function.
+
+    Args:
+        function: Function to inspect
+
+    Returns:
+        Return type annotation, or None if not annotated or type is Any
+    """
+    type_hints = get_type_hints(function)
+    return_type = type_hints.get("return")
+    if return_type is None or return_type is Any:
+        return None
+
+    if isinstance(return_type, type) and return_type in (type(None),):
+        return None
+
+    if isinstance(return_type, type):
+        return cast(Type[Any], return_type)
+
+    return None
+
+
+def is_pydantic_model(type_annotation: Any) -> bool:
+    """Check if a type annotation is a Pydantic BaseModel.
+
+    Args:
+        type_annotation: Type to check
+
+    Returns:
+        True if the type is a Pydantic BaseModel subclass, False otherwise
+    """
+    try:
+        return isinstance(type_annotation, type) and issubclass(
+            type_annotation, BaseModel
+        )
+    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/src/communication/typing_utils.py

@@ -1,90 +0,0 @@
-from __future__ import annotations
-import inspect
-from typing import Any, Optional, Type, get_type_hints, cast
-
-from pydantic import BaseModel
-
-
-class TypingError(Exception):
-    """Raised when type inference fails."""
-
-
-def _strip_self(params: list[inspect.Parameter]) -> list[inspect.Parameter]:
-    if not params:
-        return params
-    first = params[0]
-    if first.name in ("self", "cls"):
-        return params[1:]
-    return params
-
-
-def infer_input_type(function: Any) -> Optional[Type[Any]]:
-    """Infer the input type annotation from a function's first parameter.
-
-    Args:
-        function: Function to inspect
-
-    Returns:
-        Type annotation of the first parameter, or None if no parameters or type is Any
-
-    Raises:
-        TypingError: If the first parameter lacks a type annotation
-    """
-    signature = inspect.signature(function)
-    parameters = _strip_self(list(signature.parameters.values()))
-    if not parameters:
-        return None
-
-    first_param = parameters[0]
-    type_hints = get_type_hints(function)
-    if first_param.name not in type_hints:
-        raise TypingError(f"First parameter '{first_param.name}' must be annotated")
-
-    hint_type = type_hints[first_param.name]
-    if hint_type is Any:
-        return None
-
-    if isinstance(hint_type, type):
-        return cast(Type[Any], hint_type)
-
-    return None
-
-
-def infer_output_type(function: Any) -> Optional[Type[Any]]:
-    """Infer the return type annotation from a function.
-
-    Args:
-        function: Function to inspect
-
-    Returns:
-        Return type annotation, or None if not annotated or type is Any
-    """
-    type_hints = get_type_hints(function)
-    return_type = type_hints.get("return")
-    if return_type is None or return_type is Any:
-        return None
-
-    if isinstance(return_type, type) and return_type in (type(None),):
-        return None
-
-    if isinstance(return_type, type):
-        return cast(Type[Any], return_type)
-
-    return None
-
-
-def is_pydantic_model(type_annotation: Any) -> bool:
-    """Check if a type annotation is a Pydantic BaseModel.
-
-    Args:
-        type_annotation: Type to check
-
-    Returns:
-        True if the type is a Pydantic BaseModel subclass, False otherwise
-    """
-    try:
-        return isinstance(type_annotation, type) and issubclass(
-            type_annotation, BaseModel
-        )
-    except Exception:
-        return False