pydantic-rpc 0.8.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

pydantic_rpc/decorators.py

@@ -0,0 +1,138 @@
+"""Decorators for adding protobuf options to RPC methods."""
+
+from typing import Any, Callable, Dict, List, Optional, TypeVar
+from functools import wraps
+
+from .options import OptionMetadata, OPTION_METADATA_ATTR
+
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def http_option(
+    method: str,
+    path: str,
+    body: Optional[str] = None,
+    response_body: Optional[str] = None,
+    additional_bindings: Optional[List[Dict[str, Any]]] = None,
+) -> Callable[[F], F]:
+    """
+    Decorator to add google.api.http option to an RPC method.
+
+    Args:
+        method: HTTP method (GET, POST, PUT, DELETE, PATCH)
+        path: URL path template (e.g., "/v1/books/{id}")
+        body: Request body mapping (e.g., "*" for entire body)
+        response_body: Response body mapping (specific field to return)
+        additional_bindings: List of additional HTTP bindings
+
+    Example:
+        @http_option(method="GET", path="/v1/books/{id}")
+        async def get_book(self, request: GetBookRequest) -> Book:
+            ...
+    """
+
+    def decorator(func: F) -> F:
+        # Get or create option metadata
+        if not hasattr(func, OPTION_METADATA_ATTR):
+            setattr(func, OPTION_METADATA_ATTR, OptionMetadata())
+
+        metadata: OptionMetadata = getattr(func, OPTION_METADATA_ATTR)
+
+        # Set HTTP option
+        metadata.set_http_option(
+            method=method,
+            path=path,
+            body=body,
+            response_body=response_body,
+            additional_bindings=additional_bindings,
+        )
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        # Preserve the metadata on the wrapper
+        setattr(wrapper, OPTION_METADATA_ATTR, metadata)
+
+        return wrapper  # type: ignore
+
+    return decorator
+
+
+def proto_option(name: str, value: Any) -> Callable[[F], F]:
+    """
+    Decorator to add a generic protobuf option to an RPC method.
+
+    Args:
+        name: Option name (e.g., "deprecated", "idempotency_level")
+        value: Option value
+
+    Example:
+        @proto_option("deprecated", True)
+        @proto_option("idempotency_level", "IDEMPOTENT")
+        async def old_method(self, request: Request) -> Response:
+            ...
+    """
+
+    def decorator(func: F) -> F:
+        # Get or create option metadata
+        if not hasattr(func, OPTION_METADATA_ATTR):
+            setattr(func, OPTION_METADATA_ATTR, OptionMetadata())
+
+        metadata: OptionMetadata = getattr(func, OPTION_METADATA_ATTR)
+
+        # Add proto option
+        metadata.add_proto_option(name=name, value=value)
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        # Preserve the metadata on the wrapper
+        setattr(wrapper, OPTION_METADATA_ATTR, metadata)
+
+        return wrapper  # type: ignore
+
+    return decorator
+
+
+def get_method_options(method: Callable) -> Optional[OptionMetadata]:
+    """
+    Get option metadata from a method.
+
+    Args:
+        method: The method to get options from
+
+    Returns:
+        OptionMetadata if present, None otherwise
+    """
+    return getattr(method, OPTION_METADATA_ATTR, None)
+
+
+def has_http_option(method: Callable) -> bool:
+    """
+    Check if a method has an HTTP option.
+
+    Args:
+        method: The method to check
+
+    Returns:
+        True if the method has an HTTP option, False otherwise
+    """
+    metadata = get_method_options(method)
+    return metadata is not None and metadata.http_option is not None
+
+
+def has_proto_options(method: Callable) -> bool:
+    """
+    Check if a method has any proto options.
+
+    Args:
+        method: The method to check
+
+    Returns:
+        True if the method has proto options, False otherwise
+    """
+    metadata = get_method_options(method)
+    return metadata is not None and len(metadata.proto_options) > 0

pydantic_rpc/options.py

@@ -0,0 +1,134 @@
+"""Protocol Buffer options support for pydantic-rpc."""
+
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+
+
+class HttpBinding(BaseModel):
+    """HTTP binding configuration for a single HTTP method."""
+
+    method: str = Field(..., description="HTTP method (get, post, put, delete, patch)")
+    path: Optional[str] = Field(None, description="URL path template")
+    body: Optional[str] = Field(None, description="Request body mapping")
+    response_body: Optional[str] = Field(None, description="Response body mapping")
+
+    def to_proto_dict(self) -> Dict[str, Any]:
+        """Convert to protobuf option format."""
+        result = {}
+        if self.path:
+            result[self.method.lower()] = self.path
+        if self.body:
+            result["body"] = self.body
+        if self.response_body:
+            result["response_body"] = self.response_body
+        return result
+
+
+class HttpOption(BaseModel):
+    """Google API HTTP option configuration."""
+
+    method: str = Field(..., description="Primary HTTP method")
+    path: str = Field(..., description="Primary URL path template")
+    body: Optional[str] = Field(None, description="Request body mapping")
+    response_body: Optional[str] = Field(None, description="Response body mapping")
+    additional_bindings: List[Dict[str, Any]] = Field(
+        default_factory=list, description="Additional HTTP bindings"
+    )
+
+    def to_proto_string(self) -> str:
+        """Convert to protobuf option string format."""
+        lines = []
+        lines.append("option (google.api.http) = {")
+
+        # Primary binding
+        lines.append(f'  {self.method.lower()}: "{self.path}"')
+
+        # Body mapping
+        if self.body:
+            lines.append(f'  body: "{self.body}"')
+
+        # Response body mapping
+        if self.response_body:
+            lines.append(f'  response_body: "{self.response_body}"')
+
+        # Additional bindings
+        for binding in self.additional_bindings:
+            lines.append("  additional_bindings {")
+            for key, value in binding.items():
+                if key == "body":
+                    lines.append(f'    {key}: "{value}"')
+                else:
+                    lines.append(f'    {key}: "{value}"')
+            lines.append("  }")
+
+        lines.append("};")
+        return "\n".join(lines)
+
+
+class ProtoOption(BaseModel):
+    """Generic protocol buffer option."""
+
+    name: str = Field(..., description="Option name")
+    value: Any = Field(..., description="Option value")
+
+    def to_proto_string(self) -> str:
+        """Convert to protobuf option string format."""
+        if isinstance(self.value, bool):
+            value_str = "true" if self.value else "false"
+        elif isinstance(self.value, str):
+            # Check if it's an enum value (no quotes) or string literal (quotes)
+            if self.value.isupper() or "_" in self.value:
+                # Likely an enum value
+                value_str = self.value
+            else:
+                value_str = f'"{self.value}"'
+        else:
+            value_str = str(self.value)
+
+        return f"option {self.name} = {value_str};"
+
+
+class OptionMetadata(BaseModel):
+    """Metadata container for method/service options."""
+
+    http_option: Optional[HttpOption] = None
+    proto_options: List[ProtoOption] = Field(default_factory=list)
+
+    def add_proto_option(self, name: str, value: Any) -> None:
+        """Add a generic proto option."""
+        self.proto_options.append(ProtoOption(name=name, value=value))
+
+    def set_http_option(
+        self,
+        method: str,
+        path: str,
+        body: Optional[str] = None,
+        response_body: Optional[str] = None,
+        additional_bindings: Optional[List[Dict[str, Any]]] = None,
+    ) -> None:
+        """Set the HTTP option configuration."""
+        self.http_option = HttpOption(
+            method=method,
+            path=path,
+            body=body,
+            response_body=response_body,
+            additional_bindings=additional_bindings or [],
+        )
+
+    def to_proto_strings(self) -> List[str]:
+        """Convert all options to protobuf strings."""
+        result = []
+
+        # Add HTTP option first if present
+        if self.http_option:
+            result.append(self.http_option.to_proto_string())
+
+        # Add other proto options
+        for option in self.proto_options:
+            result.append(option.to_proto_string())
+
+        return result
+
+
+# Option metadata attribute name used on methods
+OPTION_METADATA_ATTR = "__pydantic_rpc_options__"

pydantic_rpc/tls.py

@@ -0,0 +1,96 @@
+"""TLS configuration for gRPC servers."""
+
+from dataclasses import dataclass
+from typing import Optional, Any
+import grpc
+
+
+@dataclass
+class GrpcTLSConfig:
+    """Configuration for gRPC server TLS.
+
+    Args:
+        cert_chain: The PEM-encoded server certificate chain.
+        private_key: The PEM-encoded private key for the server certificate.
+        root_certs: Optional PEM-encoded root certificates for verifying client certificates.
+                   If provided with require_client_cert=True, enables mTLS.
+        require_client_cert: If True, requires and verifies client certificates (mTLS).
+    """
+
+    cert_chain: bytes
+    private_key: bytes
+    root_certs: Optional[bytes] = None
+    require_client_cert: bool = False
+
+    def to_server_credentials(self) -> grpc.ServerCredentials:
+        """Convert to gRPC ServerCredentials."""
+        private_key_certificate_chain_pairs = [(self.private_key, self.cert_chain)]
+
+        if self.require_client_cert and self.root_certs:
+            # mTLS: require and verify client certificates
+            return grpc.ssl_server_credentials(
+                private_key_certificate_chain_pairs,
+                root_certificates=self.root_certs,
+                require_client_auth=True,
+            )
+        elif self.root_certs:
+            # Optional client certificates
+            return grpc.ssl_server_credentials(
+                private_key_certificate_chain_pairs,
+                root_certificates=self.root_certs,
+                require_client_auth=False,
+            )
+        else:
+            # Server TLS only, no client certificate validation
+            return grpc.ssl_server_credentials(private_key_certificate_chain_pairs)
+
+
+def extract_peer_identity(context: grpc.ServicerContext) -> Optional[str]:
+    """Extract the peer identity from the ServicerContext.
+
+    For mTLS connections, this returns the client's certificate subject.
+
+    Args:
+        context: The gRPC ServicerContext from a request handler.
+
+    Returns:
+        The peer identity string if available, None otherwise.
+    """
+    auth_context: Any = context.auth_context()
+    if auth_context:
+        # The peer identity is typically stored under the 'x509_common_name' key
+        # or 'x509_subject_alternative_name' for SANs
+        identities = auth_context.get("x509_common_name")
+        if identities and len(identities) > 0:
+            # Return the first identity (there's usually only one CN)
+            # gRPC returns bytes, so we decode to string
+            identity_bytes: bytes = identities[0]
+            return identity_bytes.decode("utf-8")
+
+        # Fallback to SAN if CN is not available
+        san_identities = auth_context.get("x509_subject_alternative_name")
+        if san_identities and len(san_identities) > 0:
+            # gRPC returns bytes, so we decode to string
+            san_bytes: bytes = san_identities[0]
+            return san_bytes.decode("utf-8")
+
+    return None
+
+
+def extract_peer_certificate_chain(context: grpc.ServicerContext) -> Optional[bytes]:
+    """Extract the peer's certificate chain from the ServicerContext.
+
+    Args:
+        context: The gRPC ServicerContext from a request handler.
+
+    Returns:
+        The peer's certificate chain in PEM format if available, None otherwise.
+    """
+    auth_context: Any = context.auth_context()
+    if auth_context:
+        cert_chain = auth_context.get("x509_peer_certificate")
+        if cert_chain and len(cert_chain) > 0:
+            cert_bytes: bytes = cert_chain[0]
+            return cert_bytes
+
+    return None

{pydantic_rpc-0.8.0.dist-info → pydantic_rpc-0.10.0.dist-info}/METADATA

@@ -1,16 +1,15 @@
 Metadata-Version: 2.3
 Name: pydantic-rpc
-Version: 0.8.0
+Version: 0.10.0
 Summary: A Python library for building gRPC/ConnectRPC services with Pydantic models.
 Author: Yasushi Itoh
-Requires-Dist: annotated-types>=0.5.0
+Requires-Dist: annotated-types==0.7.0
 Requires-Dist: pydantic>=2.1.1
 Requires-Dist: grpcio>=1.56.2
 Requires-Dist: grpcio-tools>=1.56.2
 Requires-Dist: grpcio-reflection>=1.56.2
 Requires-Dist: grpcio-health-checking>=1.56.2
-Requires-Dist: sonora>=0.2.3
-Requires-Dist: connecpy==2.0.0
+Requires-Dist: connecpy>=2.2.0
 Requires-Dist: mcp>=1.9.4
 Requires-Dist: starlette>=0.27.0
 Requires-Python: >=3.11
@@ -76,7 +75,7 @@ import asyncio
 from openai import AsyncOpenAI
 from pydantic_ai import Agent
 from pydantic_ai.models.openai import OpenAIModel
-from pydantic_rpc import ConnecpyASGIApp, Message
+from pydantic_rpc import ASGIApp, Message
 
 
 class CityLocation(Message):
@@ -107,7 +106,7 @@ class OlympicsLocationAgent:
         result = await self._agent.run(req.prompt())
         return result.data
 
-app = ConnecpyASGIApp()
+app = ASGIApp()
 app.mount(OlympicsLocationAgent())
 
 ```
@@ -123,10 +122,10 @@ app.mount(OlympicsLocationAgent())
   - 💚 **Health Checking:** Built-in support for gRPC health checks using `grpc_health.v1`.
   - 🔎 **Server Reflection:** Built-in support for gRPC server reflection.
   - ⚡ **Asynchronous Support:** Easily create asynchronous gRPC services with `AsyncIOServer`.
-- **For gRPC-Web:**
-  - 🌐 **WSGI/ASGI Support:** Create gRPC-Web services that can run as WSGI or ASGI applications powered by `Sonora`.
 - **For Connect-RPC:**
-  - 🌐 **Connecpy Support:** Partially supports Connect-RPC via `Connecpy`.
+  - 🌐 **Full Protocol Support:** Native Connect-RPC support via `Connecpy` v2.2.0+
+  - 🔄 **All Streaming Patterns:** Unary, server streaming, client streaming, and bidirectional streaming
+  - 🌐 **WSGI/ASGI Applications:** Run as standard WSGI or ASGI applications for easy deployment
 - 🛠️ **Pre-generated Protobuf Files and Code:** Pre-generate proto files and corresponding code via the CLI. By setting the environment variable (PYDANTIC_RPC_SKIP_GENERATION), you can skip runtime generation.
 - 🤖 **MCP (Model Context Protocol) Support:** Expose your services as tools for AI assistants using the official MCP SDK, supporting both stdio and HTTP/SSE transports.
 
@@ -140,7 +139,11 @@ pip install pydantic-rpc
 
 ## 🚀 Getting Started
 
-### 🔧 Synchronous Service Example
+PydanticRPC supports two main protocols:
+- **gRPC**: Traditional gRPC services with `Server` and `AsyncIOServer`
+- **Connect-RPC**: Modern HTTP-based RPC with `ASGIApp` and `WSGIApp`
+
+### 🔧 Synchronous gRPC Service Example
 
 ```python
 from pydantic_rpc import Server, Message
@@ -161,7 +164,7 @@ if __name__ == "__main__":
     server.run(Greeter())
 ```
 
-### ⚙️ Asynchronous Service Example
+### ⚙️ Asynchronous gRPC Service Example
 
 ```python
 import asyncio
@@ -194,7 +197,7 @@ if __name__ == "__main__":
 
 The AsyncIOServer automatically handles graceful shutdown on SIGTERM and SIGINT signals.
 
-### 🌐 ASGI Application Example
+### 🌐 Connect-RPC ASGI Application Example
 
 ```python
 from pydantic_rpc import ASGIApp, Message
@@ -206,27 +209,17 @@ class HelloReply(Message):
     message: str
 
 class Greeter:
-    def say_hello(self, request: HelloRequest) -> HelloReply:
+    async def say_hello(self, request: HelloRequest) -> HelloReply:
         return HelloReply(message=f"Hello, {request.name}!")
 
-
-async def app(scope, receive, send):
-    """ASGI application.
-
-    Args:
-        scope (dict): The ASGI scope.
-        receive (callable): The receive function.
-        send (callable): The send function.
-    """
-    pass
-
-# Please note that `app` is any ASGI application, such as FastAPI or Starlette.
-
-app = ASGIApp(app)
+app = ASGIApp()
 app.mount(Greeter())
+
+# Run with uvicorn:
+# uvicorn script:app --host 0.0.0.0 --port 8000
 ```
 
-### 🌐 WSGI Application Example
+### 🌐 Connect-RPC WSGI Application Example
 
 ```python
 from pydantic_rpc import WSGIApp, Message
@@ -241,31 +234,69 @@ class Greeter:
     def say_hello(self, request: HelloRequest) -> HelloReply:
         return HelloReply(message=f"Hello, {request.name}!")
 
-def app(environ, start_response):
-    """WSGI application.
-
-    Args:
-        environ (dict): The WSGI environment.
-        start_response (callable): The start_response function.
-    """
-    pass
-
-# Please note that `app` is any WSGI application, such as Flask or Django.
-
-app = WSGIApp(app)
+app = WSGIApp()
 app.mount(Greeter())
+
+# Run with gunicorn:
+# gunicorn script:app
 ```
 
-### 🏆 Connecpy (Connect-RPC) Example
+### 🏆 Connect-RPC with Streaming Example
 
-PydanticRPC also partially supports Connect-RPC via connecpy. Check out “greeting_connecpy.py” for an example:
+PydanticRPC provides native Connect-RPC support via Connecpy v2.2.0+, including full streaming capabilities and PEP 8 naming conventions. Check out our ASGI examples:
 
 ```bash
-uv run greeting_connecpy.py
+# Run with uvicorn
+uv run uvicorn greeting_asgi:app --port 3000
+
+# Or run streaming example
+uv run python examples/streaming_connecpy.py
 ```
 
 This will launch a Connecpy-based ASGI application that uses the same Pydantic models to serve Connect-RPC requests.
 
+#### Streaming Support with Connecpy
+
+Connecpy v2.2.0 provides full support for streaming RPCs with automatic PEP 8 naming (snake_case):
+
+```python
+from typing import AsyncIterator
+from pydantic_rpc import ASGIApp, Message
+
+class StreamRequest(Message):
+    text: str
+    count: int
+
+class StreamResponse(Message):
+    text: str
+    index: int
+
+class StreamingService:
+    # Server streaming
+    async def server_stream(self, request: StreamRequest) -> AsyncIterator[StreamResponse]:
+        for i in range(request.count):
+            yield StreamResponse(text=f"{request.text}_{i}", index=i)
+    
+    # Client streaming
+    async def client_stream(self, requests: AsyncIterator[StreamRequest]) -> StreamResponse:
+        texts = []
+        async for req in requests:
+            texts.append(req.text)
+        return StreamResponse(text=" ".join(texts), index=len(texts))
+    
+    # Bidirectional streaming
+    async def bidi_stream(
+        self, requests: AsyncIterator[StreamRequest]
+    ) -> AsyncIterator[StreamResponse]:
+        idx = 0
+        async for req in requests:
+            yield StreamResponse(text=f"Echo: {req.text}", index=idx)
+            idx += 1
+
+app = ASGIApp()
+app.mount(StreamingService())
+```
+
 > [!NOTE]
 > Please install `protoc-gen-connecpy` to run the Connecpy example.
 >
@@ -302,9 +333,9 @@ export PYDANTIC_RPC_RESERVED_FIELDS=1
 
 ## 💎 Advanced Features
 
-### 🌊 Response Streaming
-PydanticRPC supports streaming responses only for asynchronous gRPC and gRPC-Web services.
-If a service class method’s return type is `typing.AsyncIterator[T]`, the method is considered a streaming method.
+### 🌊 Response Streaming (gRPC)
+PydanticRPC supports streaming responses for both gRPC and Connect-RPC services.
+If a service class method's return type is `typing.AsyncIterator[T]`, the method is considered a streaming method.
 
 
 Please see the sample code below:
@@ -870,9 +901,45 @@ class GoodMessage(Message):
 - Test error cases thoroughly
 - Be aware that errors fail silently
 
+### 🔒 TLS/mTLS Support
+
+PydanticRPC provides built-in support for TLS (Transport Layer Security) and mTLS (mutual TLS) for secure gRPC communication.
+
+```python
+from pydantic_rpc import AsyncIOServer, GrpcTLSConfig, extract_peer_identity
+import grpc
+
+# Basic TLS (server authentication only)
+tls_config = GrpcTLSConfig(
+    cert_chain=server_cert_bytes,
+    private_key=server_key_bytes,
+    require_client_cert=False
+)
+
+# mTLS (mutual authentication)
+tls_config = GrpcTLSConfig(
+    cert_chain=server_cert_bytes,
+    private_key=server_key_bytes,
+    root_certs=ca_cert_bytes,  # CA to verify client certificates
+    require_client_cert=True
+)
+
+# Create server with TLS
+server = AsyncIOServer(tls=tls_config)
+
+# Extract client identity in service methods
+class SecureService:
+    async def secure_method(self, request, context: grpc.ServicerContext):
+        client_identity = extract_peer_identity(context)
+        if client_identity:
+            print(f"Authenticated client: {client_identity}")
+```
+
+For a complete example, see [examples/tls_server.py](examples/tls_server.py) and [examples/tls_client.py](examples/tls_client.py).
+
 ### 🔗 Multiple Services with Custom Interceptors
 
-PydanticRPC supports defining and running multiple services in a single server:
+PydanticRPC supports defining and running multiple gRPC services in a single server:
 
 ```python
 from datetime import datetime
@@ -1003,11 +1070,11 @@ Any MCP-compatible client can connect to your service. For example, to configure
 MCP can also be mounted to existing ASGI applications:
 
 ```python
-from pydantic_rpc import ConnecpyASGIApp
+from pydantic_rpc import ASGIApp
 from pydantic_rpc.mcp import MCPExporter
 
 # Create Connect-RPC ASGI app
-app = ConnecpyASGIApp()
+app = ASGIApp()
 app.mount(MathService())
 
 # Add MCP support via HTTP/SSE

pydantic_rpc-0.10.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+pydantic_rpc/__init__.py,sha256=a8c4ed1a731b7f601006cbbd4aff16d43bbca0b7ffb02c698f1c79dccefe2f8e,781
+pydantic_rpc/core.py,sha256=b2867838460a23b1ce302c9d7e6ef2a2e711c6c84887a50e3ad40b94ff5dc53c,112505
+pydantic_rpc/decorators.py,sha256=2f2dc3f642a6e40d05187901e75269415a70b8f18d555e6c7ac923dee149d34c,3852
+pydantic_rpc/mcp/__init__.py,sha256=f05ad62cc38db5c5972e16870c484523c58c5ac650d8454706f1ce4539cc7a52,123
+pydantic_rpc/mcp/converter.py,sha256=b60dcaf82e6bff6be4b2ab8b1e9f2d16e09cb98d8f00182a4f6f73d1a78848a4,4158
+pydantic_rpc/mcp/exporter.py,sha256=20833662f9a973ed9e1a705b9b59aaa2533de6c514ebd87ef66664a430a0d04f,10239
+pydantic_rpc/options.py,sha256=6094036184a500b92715fd91d31ecc501460a56de47dcf6024c6335ae8e5d6e3,4561
+pydantic_rpc/py.typed,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
+pydantic_rpc/tls.py,sha256=0eb290cc09c8ebedc71e7a97c01736d9675a314f70ebd80a2ce73e3f1689d359,3567
+pydantic_rpc-0.10.0.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
+pydantic_rpc-0.10.0.dist-info/entry_points.txt,sha256=72a47b1d2cae3abc045710fe0c2c2e6dfbb051fbf6960c22b62488004e9188ba,57
+pydantic_rpc-0.10.0.dist-info/METADATA,sha256=8819d19940dcb5a2718e9455725e976babebeeee32ba2b016135f29ba3dda67c,32096
+pydantic_rpc-0.10.0.dist-info/RECORD,,

pydantic_rpc-0.8.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-pydantic_rpc/__init__.py,sha256=7dbedaf58742b13e96954afb68ca91f9800a2faf0799f78da6070c9c88511065,440
-pydantic_rpc/core.py,sha256=2e2bce8aaf677ae50fdcdde51507da605ed77efe5e1a522e52b406c416b18318,104265
-pydantic_rpc/mcp/__init__.py,sha256=f05ad62cc38db5c5972e16870c484523c58c5ac650d8454706f1ce4539cc7a52,123
-pydantic_rpc/mcp/converter.py,sha256=b60dcaf82e6bff6be4b2ab8b1e9f2d16e09cb98d8f00182a4f6f73d1a78848a4,4158
-pydantic_rpc/mcp/exporter.py,sha256=20833662f9a973ed9e1a705b9b59aaa2533de6c514ebd87ef66664a430a0d04f,10239
-pydantic_rpc/py.typed,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
-pydantic_rpc-0.8.0.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
-pydantic_rpc-0.8.0.dist-info/entry_points.txt,sha256=72a47b1d2cae3abc045710fe0c2c2e6dfbb051fbf6960c22b62488004e9188ba,57
-pydantic_rpc-0.8.0.dist-info/METADATA,sha256=1cb4d588db71dd052e24c12c63d368c89520279bc9c9a8b10658fdd0d83ee0ec,29803
-pydantic_rpc-0.8.0.dist-info/RECORD,,