pyrpc-core 0.1.0a1__tar.gz

pyrpc_core-0.1.0a1/.gitignore

@@ -0,0 +1,154 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+!docs/lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Used for packaging Python scripts into standalone executables
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.stats
+.hypothesis/
+.pytest_cache/
+pytestdebug.log
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   Project-specific python versions
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if Pipfile.lock (and requirements.txt) are not
+#   preferred, then add them into the ignore list.
+# Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+# pdm.lock
+# .pdm-python
+
+# PEP 582; used by e.g. github.com/fannheyward/coc-pyright
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyderformpoint
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# OS X
+.DS_Store
+
+# Node modules
+node_modules
+dist

pyrpc_core-0.1.0a1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: pyrpc-core
+Version: 0.1.0a1
+Summary: pyRPC Core - tRPC-style RPC protocol and runtime for Python
+Requires-Python: >=3.11
+Requires-Dist: anyio>=4.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pydantic>=2.0

pyrpc_core-0.1.0a1/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "pyrpc-core"
+version = "0.1.0-alpha.1"
+description = "pyRPC Core - tRPC-style RPC protocol and runtime for Python"
+requires-python = ">=3.11"
+dependencies = [
+    "pydantic>=2.0",
+    "httpx>=0.24.0",
+    "anyio>=4.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pyrpc_core"]

pyrpc_core-0.1.0a1/src/pyrpc_core/__init__.py

@@ -0,0 +1,25 @@
+__version__ = "0.1.0"
+
+from .client.python_client import RPCClient, RPCError
+from .core.decorators import default_router, rpc, model
+from .core.introspection import get_procedure_schema, get_registry_schema
+from .core.interpreter import handle_request
+from .core.models import RpcRequest, RpcResponse
+from .core.registry import Router
+from .transport.asgi import PyRPCAsgiApp, app as asgi_app
+
+__all__ = [
+    "Router",
+    "rpc",
+    "model",
+    "default_router",
+    "RpcRequest",
+    "RpcResponse",
+    "handle_request",
+    "PyRPCAsgiApp",
+    "asgi_app",
+    "RPCClient",
+    "RPCError",
+    "get_procedure_schema",
+    "get_registry_schema",
+]

pyrpc_core-0.1.0a1/src/pyrpc_core/client/python_client.py

@@ -0,0 +1,139 @@
+import uuid
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+
+class RPCError(Exception):
+    """
+    Structured RPC error.
+    """
+
+    def __init__(self, code: int, message: str) -> None:
+        self.code = code
+        self.message = message
+        super().__init__(f"RPC {code}: {message}")
+
+
+class RPCClient:
+    """
+    A dynamic RPC client for pyRPC.
+    Allows calling remote procedures as if they were local methods.
+    """
+
+    def __init__(
+        self, 
+        base_url: str, 
+        async_client: Optional[httpx.AsyncClient] = None,
+        sync_client: Optional[httpx.Client] = None
+    ) -> None:
+        """
+        Initialize the RPC client.
+
+        Args:
+            base_url: The base URL of the pyRPC server.
+            async_client: Optional custom async httpx client.
+            sync_client: Optional custom sync httpx client.
+        """
+        self.base_url = base_url.rstrip("/")
+        self._async_client = async_client or httpx.AsyncClient(base_url=self.base_url)
+        self._sync_client = sync_client or httpx.Client(base_url=self.base_url)
+
+    def __getattr__(self, name: str) -> Any:
+        """
+        Returns a callable that executes the RPC.
+        Defaults to sync execution unless used in an async context or explicitly called.
+        """
+
+        class CallableRPC:
+            def __init__(self, client: "RPCClient", method: str):
+                self.client = client
+                self.method = method
+
+            def __call__(self, *args: Any, **kwargs: Any) -> Any:
+                return self.client.call_sync(self.method, *args, **kwargs)
+
+            def __await__(self):
+                # This is a bit tricky for a dual-purpose object.
+                # Usually, we'd want `await client.add(1, 2)` to work.
+                # However, `client.add(1, 2)` is already called.
+                # So we return the result of call_async if it was awaited.
+                # But `client.add(1, 2)` returns a result, not a coroutine.
+                # To support both, we'd need the __getattr__ to return an object 
+                # that is both a callable and awaitable.
+                pass
+
+        # Simplified approach: expose explicit call_async and call_sync, 
+        # and make __getattr__ return an object that decides based on usage?
+        # Actually, let's stick to the original robust suggestion of clear separation 
+        # but keep the convenience of dynamic calls by returning a helper.
+        
+        return RPCCallable(self, name)
+
+    async def call_async(self, method: str, *args: Any, **kwargs: Any) -> Any:
+        payload = self._prepare_payload(method, *args, **kwargs)
+        response = await self._async_client.post("/rpc", json=payload)
+        return self._handle_response(response)
+
+    def call_sync(self, method: str, *args: Any, **kwargs: Any) -> Any:
+        payload = self._prepare_payload(method, *args, **kwargs)
+        response = self._sync_client.post("/rpc", json=payload)
+        return self._handle_response(response)
+
+    def _prepare_payload(self, method: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        params: Union[List[Any], Dict[str, Any]]
+        if kwargs:
+            params = kwargs
+        else:
+            params = list(args)
+
+        return {
+            "id": str(uuid.uuid4()),
+            "method": method,
+            "params": params,
+        }
+
+    def _handle_response(self, response: httpx.Response) -> Any:
+        response.raise_for_status()
+        data = response.json()
+        if "error" in data and data["error"]:
+            error = data["error"]
+            raise RPCError(error["code"], error["message"])
+        return data.get("result")
+
+    async def aclose(self) -> None:
+        await self._async_client.aclose()
+
+    def close(self) -> None:
+        self._sync_client.close()
+
+    async def __aenter__(self) -> "RPCClient":
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        await self.aclose()
+
+    def __enter__(self) -> "RPCClient":
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        self.close()
+
+
+class RPCCallable:
+    """
+    Helper for dynamic method calls.
+    Supports both sync call and async call (via .aio() or similar).
+    """
+
+    def __init__(self, client: RPCClient, method: str):
+        self.client = client
+        self.method = method
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """Sync call by default."""
+        return self.client.call_sync(self.method, *args, **kwargs)
+
+    async def aio(self, *args: Any, **kwargs: Any) -> Any:
+        """Explicit async call."""
+        return await self.client.call_async(self.method, *args, **kwargs)

pyrpc_core-0.1.0a1/src/pyrpc_core/core/decorators.py

@@ -0,0 +1,8 @@
+from pydantic.dataclasses import dataclass as model
+from .registry import Router
+
+# Global default router for easy use
+default_router = Router()
+
+# Alias the rpc decorator for the global router
+rpc = default_router.rpc

pyrpc_core-0.1.0a1/src/pyrpc_core/core/interpreter.py

@@ -0,0 +1,70 @@
+import asyncio
+import inspect
+from typing import Any, Dict, Optional
+
+from .decorators import default_router
+from .registry import Router
+from pydantic import ValidationError
+
+from .models import RpcErrorModel, RpcRequest, RpcResponse
+
+from .procedure import Procedure, ProcedureError, _format_validation_error
+
+async def handle_request(
+    payload: Dict[str, Any], 
+    router: Optional[Router] = None
+) -> Dict[str, Any]:
+    """
+    Handle an incoming RPC request using pre-compiled Procedures.
+    """
+    if router is None:
+        router = default_router
+
+    request_id = payload.get("id")
+    try:
+        # 1. Parse Envelope
+        try:
+            request = RpcRequest.model_validate(payload)
+        except ValidationError as e:
+            return RpcResponse(
+                id=request_id,
+                error=RpcErrorModel(
+                    code=-32600, 
+                    message="Invalid request",
+                    data=_format_validation_error(e)
+                ),
+            ).model_dump()
+
+        # 2. Find Procedure
+        procedure = router.get(request.method)
+        if not procedure:
+            return RpcResponse(
+                id=request_id,
+                error=RpcErrorModel(code=-32601, message=f"Method not found: {request.method}"),
+            ).model_dump()
+
+        # 3. Execute Procedure (Validation and Call happens inside)
+        try:
+            result = await procedure.execute(request.params if request.params is not None else {})
+            return RpcResponse(id=request_id, result=result).model_dump()
+
+        except ProcedureError as pe:
+            return RpcResponse(
+                id=request_id,
+                error=RpcErrorModel(
+                    code=pe.code, 
+                    message=pe.message,
+                    data=pe.data
+                ),
+            ).model_dump()
+        except Exception as e:
+            return RpcResponse(
+                id=request_id,
+                error=RpcErrorModel(code=-32603, message=str(e)),
+            ).model_dump()
+
+    except Exception as e:
+        return RpcResponse(
+            id=request_id,
+            error=RpcErrorModel(code=-32600, message=f"Invalid request: {str(e)}"),
+        ).model_dump()

pyrpc_core-0.1.0a1/src/pyrpc_core/core/introspection.py

@@ -0,0 +1,73 @@
+import inspect
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel
+from .procedure import Procedure
+
+
+class ParameterSchema(BaseModel):
+    name: str
+    type: str
+    schema_: Dict[str, Any]
+    required: bool
+    default: Optional[Any] = None
+
+
+class ProcedureSchema(BaseModel):
+    name: str
+    parameters: List[ParameterSchema]
+    return_type: str
+    return_schema: Dict[str, Any]
+    doc: Optional[str] = None
+
+
+def get_procedure_schema(proc: Procedure) -> ProcedureSchema:
+    """
+    Generate a schema from a compiled Procedure.
+    """
+    parameters = []
+
+    for param_name, param in proc.sig.parameters.items():
+        # Get parameter type
+        param_type = param.annotation if param.annotation is not inspect.Parameter.empty else Any
+        
+        # Use pre-built adapter if available
+        adapter = proc.arg_adapters.get(param_name)
+        if adapter:
+            param_json_schema = adapter.json_schema()
+        else:
+            param_json_schema = {"type": "any"}
+
+        parameters.append(
+            ParameterSchema(
+                name=param_name,
+                type=str(param_type),
+                schema_=param_json_schema,
+                required=param.default is inspect.Parameter.empty,
+                default=param.default if param.default is not inspect.Parameter.empty else None,
+            )
+        )
+
+    # Get return type
+    return_type = proc.sig.return_annotation if proc.sig.return_annotation is not inspect.Signature.empty else Any
+    if proc.return_adapter:
+        return_json_schema = proc.return_adapter.json_schema()
+    else:
+        return_json_schema = {"type": "any"}
+
+    return ProcedureSchema(
+        name=proc.name,
+        parameters=parameters,
+        return_type=str(return_type),
+        return_schema=return_json_schema,
+        doc=inspect.getdoc(proc.fn),
+    )
+
+
+def get_registry_schema(router: Any) -> Dict[str, ProcedureSchema]:
+    """
+    Generate schemas for all procedures in a router.
+    """
+    schemas = {}
+    for name, proc in router._procedures.items():
+        schemas[name] = get_procedure_schema(proc)
+    return schemas

pyrpc_core-0.1.0a1/src/pyrpc_core/core/models.py

@@ -0,0 +1,29 @@
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+
+class RpcRequest(BaseModel):
+    """
+    Represents an RPC request.
+    """
+
+    id: Optional[Union[str, int]] = None
+    method: str
+    params: Optional[Union[List[Any], Dict[str, Any]]] = None
+
+
+class RpcErrorModel(BaseModel):
+    code: int
+    message: str
+    data: Optional[Any] = None
+
+
+class RpcResponse(BaseModel):
+    """
+    Represents an RPC response.
+    """
+
+    id: Optional[Union[int, str]] = None
+    result: Optional[Any] = None
+    error: Optional[RpcErrorModel] = None

pyrpc_core-0.1.0a1/src/pyrpc_core/core/procedure.py

@@ -0,0 +1,91 @@
+import inspect
+import asyncio
+from typing import Any, Callable, Dict, Optional, List
+from pydantic import TypeAdapter, ValidationError
+
+def _format_validation_error(e: ValidationError) -> Dict[str, Any]:
+    errors = e.errors()
+    if not errors:
+        return {"field": "unknown", "message": "Validation failed"}
+    
+    first_error = errors[0]
+    loc = ".".join(str(l) for l in first_error.get("loc", []))
+    return {
+        "field": loc,
+        "message": first_error.get("msg", "Validation failed"),
+        "type": first_error.get("type", "unknown")
+    }
+
+class ProcedureError(Exception):
+    def __init__(self, code: int, message: str, data: Optional[Dict[str, Any]] = None):
+        self.code = code
+        self.message = message
+        self.data = data or {}
+
+class Procedure:
+    """
+    Represents a 'compiled' RPC procedure.
+    All expensive introspection and validator setup happens during initialization.
+    """
+
+    def __init__(self, fn: Callable[..., Any], name: Optional[str] = None):
+        self.fn = fn
+        self.name = name or fn.__name__
+        self.sig = inspect.signature(fn)
+        self.is_async = inspect.iscoroutinefunction(fn)
+        
+        # Pre-build Pydantic TypeAdapters for all parameters
+        self.arg_adapters: Dict[str, TypeAdapter] = {}
+        for param_name, param in self.sig.parameters.items():
+            if param.annotation is not inspect.Parameter.empty and param.annotation is not Any:
+                self.arg_adapters[param_name] = TypeAdapter(param.annotation)
+        
+        # Pre-build Return TypeAdapter
+        self.return_adapter: Optional[TypeAdapter] = None
+        if self.sig.return_annotation is not inspect.Signature.empty and self.sig.return_annotation is not Any:
+            self.return_adapter = TypeAdapter(self.sig.return_annotation)
+
+    async def execute(self, params: Any) -> Any:
+        """
+        Execute the procedure with the given parameters.
+        This is the optimized 'hot path' for RPC requests.
+        """
+        # 1. Bind arguments
+        try:
+            if isinstance(params, list):
+                bound_args = self.sig.bind(*params)
+            elif isinstance(params, dict):
+                bound_args = self.sig.bind(**params)
+            else:
+                raise TypeError("Params must be a list or dict")
+        except TypeError as e:
+            raise ProcedureError(code=-32602, message=f"Invalid params: {str(e)}")
+
+        # 2. Validate arguments using pre-built adapters
+        for name, value in bound_args.arguments.items():
+            adapter = self.arg_adapters.get(name)
+            if adapter:
+                try:
+                    bound_args.arguments[name] = adapter.validate_python(value)
+                except ValidationError as ve:
+                    # Enrich the error with the parameter name if missing
+                    error_data = _format_validation_error(ve)
+                    if not error_data.get("field") or error_data["field"] == "unknown":
+                        error_data["field"] = name
+                    raise ProcedureError(code=-32602, message="Validation failed", data=error_data)
+
+        # 3. Call the function (Sync or Async)
+        if self.is_async:
+            result = await self.fn(*bound_args.args, **bound_args.kwargs)
+        else:
+            result = self.fn(*bound_args.args, **bound_args.kwargs)
+
+        # 4. Validate return type
+        if self.return_adapter:
+            try:
+                result = self.return_adapter.validate_python(result)
+            except ValidationError as ve:
+                error_data = _format_validation_error(ve)
+                raise ProcedureError(code=-32603, message="Internal Error: Return type validation failed", data=error_data)
+
+        return result

pyrpc_core-0.1.0a1/src/pyrpc_core/core/registry.py

@@ -0,0 +1,55 @@
+import threading
+from typing import Any, Callable, Dict, List, Optional
+from .procedure import Procedure
+
+class Router:
+    """
+    A Router manages a set of RPC procedures. 
+    It can be used as a decorator and merged with other routers.
+    """
+
+    def __init__(self) -> None:
+        self._procedures: Dict[str, Procedure] = {}
+        self._lock = threading.Lock()
+
+    def rpc(self, name_or_fn: Any = None) -> Any:
+        """
+        Decorator to register a function as an RPC procedure.
+        Usage: 
+            @router.rpc
+            def my_func(): ...
+            
+            @router.rpc(name="custom_name")
+            def my_func(): ...
+        """
+        def decorator(fn: Callable[..., Any]) -> Callable[..., Any]:
+            name = name_or_fn if isinstance(name_or_fn, str) else fn.__name__
+            proc = Procedure(fn, name=name)
+            self.register(name, proc)
+            return fn
+
+        if callable(name_or_fn):
+            return decorator(name_or_fn)
+        return decorator
+
+    def register(self, name: str, proc: Procedure) -> None:
+        with self._lock:
+            self._procedures[name] = proc
+
+    def merge(self, other: "Router", prefix: str = "") -> None:
+        """Merge another router into this one, optionally with a prefix."""
+        with other._lock:
+            with self._lock:
+                for name, proc in other._procedures.items():
+                    new_name = f"{prefix}{name}" if prefix else name
+                    # Create a new Procedure with the prefixed name if necessary
+                    # though proc.name is mostly for introspection
+                    self._procedures[new_name] = proc
+
+    def get(self, name: str) -> Optional[Procedure]:
+        with self._lock:
+            return self._procedures.get(name)
+
+    def list(self) -> List[str]:
+        with self._lock:
+            return list(self._procedures.keys())

pyrpc_core-0.1.0a1/src/pyrpc_core/transport/asgi.py

@@ -0,0 +1,98 @@
+import json
+from typing import Any, Callable, Dict, Optional
+
+from ..core.interpreter import handle_request
+
+
+class PyRPCAsgiApp:
+    """
+    A minimal ASGI application for serving pyRPC requests.
+    """
+
+    def __init__(self, router: Optional[Any] = None) -> None:
+        self.router = router
+
+    async def __call__(self, scope: Dict[str, Any], receive: Callable, send: Callable) -> None:
+        """
+        The ASGI entry point.
+        """
+        if scope["type"] != "http":
+            return
+
+        method = scope.get("method")
+        path = scope.get("path")
+
+        if method == "POST" and path == "/rpc":
+            await self.handle_rpc(receive, send)
+        elif method == "GET" and path == "/rpc":
+            await self.handle_introspection(send)
+        else:
+            await self.send_response(
+                send, 404, {"error": "Not Found", "message": f"Cannot {method} {path}"}
+            )
+
+    async def handle_introspection(self, send: Callable) -> None:
+        """
+        Handle a GET /rpc request for introspection.
+        """
+        from ..core.introspection import get_registry_schema
+        # We need to convert the schema objects to dicts for JSON serialization
+        # Since get_registry_schema returns a dict of ProcedureSchema, 
+        # and ProcedureSchema is likely a Pydantic model.
+        schemas = get_registry_schema(self.router)
+        
+        # Convert Pydantic models to dicts
+        response_data = {
+            name: schema.model_dump() if hasattr(schema, "model_dump") else schema
+            for name, schema in schemas.items()
+        }
+        
+        await self.send_response(send, 200, response_data)
+
+    async def handle_rpc(self, receive: Callable, send: Callable) -> None:
+        """
+        Handle an RPC request.
+        """
+        body = b""
+        more_body = True
+        while more_body:
+            message = await receive()
+            body += message.get("body", b"")
+            more_body = message.get("more_body", False)
+
+        try:
+            if not body:
+                payload = {}
+            else:
+                payload = json.loads(body)
+        except json.JSONDecodeError:
+            await self.send_response(send, 400, {"error": "Invalid JSON"})
+            return
+
+        response_dict = await handle_request(payload, router=self.router)
+        await self.send_response(send, 200, response_dict)
+
+    async def send_response(self, send: Callable, status_code: int, content: Dict[str, Any]) -> None:
+        """
+        Helper to send a JSON response.
+        """
+        response_body = json.dumps(content).encode("utf-8")
+        await send(
+            {
+                "type": "http.response.start",
+                "status": status_code,
+                "headers": [
+                    (b"content-type", b"application/json"),
+                ],
+            }
+        )
+        await send(
+            {
+                "type": "http.response.body",
+                "body": response_body,
+            }
+        )
+
+
+# Global instance for easy use
+app = PyRPCAsgiApp()

pyrpc_core-0.1.0a1/tests/test_client.py

@@ -0,0 +1,54 @@
+import pytest
+import httpx
+from pyrpc_core.client.python_client import RPCClient, RPCError
+from pyrpc_core.transport.asgi import PyRPCAsgiApp
+from pyrpc_core.core.registry import Router
+
+@pytest.mark.asyncio
+async def test_rpc_client_integration():
+    # 1. Setup Server
+    router = Router()
+    @router.rpc
+    def multiply(a: int, b: int) -> int:
+        return a * b
+        
+    @router.rpc
+    def error_func():
+        raise ValueError("Something went wrong")
+        
+    app = PyRPCAsgiApp(router=router)
+    
+    # 2. Setup Client with ASGITransport
+    # This allows the client to talk to the app without a real server
+    transport = httpx.ASGITransport(app=app)
+    async_client = httpx.AsyncClient(transport=transport, base_url="http://testserver")
+    sync_client = httpx.Client(transport=transport, base_url="http://testserver")
+    
+    async with RPCClient("http://testserver", async_client=async_client) as client:
+        # Test Async Call
+        res = await client.multiply.aio(a=5, b=6)
+        assert res == 30
+        
+        # Test Error Handling
+        with pytest.raises(RPCError) as excinfo:
+            await client.error_func.aio()
+        assert excinfo.value.code == -32603
+        assert "Something went wrong" in excinfo.value.message
+
+@pytest.mark.asyncio
+async def test_rpc_client_validation_error():
+    router = Router()
+    @router.rpc
+    def square(n: int) -> int: return n * n
+    
+    app = PyRPCAsgiApp(router=router)
+    transport = httpx.ASGITransport(app=app)
+    async_client = httpx.AsyncClient(transport=transport, base_url="http://testserver")
+    
+    async with RPCClient("http://testserver", async_client=async_client) as client:
+        # Send invalid type (string instead of int)
+        with pytest.raises(RPCError) as excinfo:
+            await client.square.aio(n="not-a-number")
+        
+        assert excinfo.value.code == -32602  # Invalid Params
+        assert "Validation failed" in excinfo.value.message

pyrpc_core-0.1.0a1/tests/test_features.py

@@ -0,0 +1,92 @@
+import pytest
+import asyncio
+from typing import List, Optional
+from pydantic import BaseModel
+from pyrpc_core.core.registry import Router
+from pyrpc_core.core.interpreter import handle_request
+
+# --- Setup Procedures ---
+
+router = Router()
+
+@router.rpc
+def add(a: int, b: int) -> int:
+    return a + b
+
+@router.rpc
+async def async_greet(name: str) -> str:
+    await asyncio.sleep(0.01)
+    return f"Hello {name}"
+
+class User(BaseModel):
+    id: int
+    username: str
+
+@router.rpc
+def get_user_name(user: User) -> str:
+    return user.username
+
+@router.rpc
+def invalid_return() -> int:
+    return "not an int"
+
+# --- Tests ---
+
+@pytest.mark.asyncio
+async def test_primitive_validation_success():
+    payload = {"id": 1, "method": "add", "params": {"a": 10, "b": 20}}
+    response = await handle_request(payload, router=router)
+    assert response["result"] == 30
+    assert response["id"] == 1
+
+@pytest.mark.asyncio
+async def test_primitive_validation_failure():
+    # Pass a string instead of an int
+    payload = {"id": 2, "method": "add", "params": {"a": "ten", "b": 20}}
+    response = await handle_request(payload, router=router)
+    assert response["error"]["code"] == -32602
+    assert "Validation failed" in response["error"]["message"]
+    assert response["error"]["data"]["field"] == "a"
+
+@pytest.mark.asyncio
+async def test_async_procedure():
+    payload = {"id": 3, "method": "async_greet", "params": ["World"]}
+    response = await handle_request(payload, router=router)
+    assert response["result"] == "Hello World"
+
+@pytest.mark.asyncio
+async def test_pydantic_model_validation():
+    payload = {
+        "id": 4, 
+        "method": "get_user_name", 
+        "params": {"user": {"id": 1, "username": "alice"}}
+    }
+    response = await handle_request(payload, router=router)
+    assert response["result"] == "alice"
+
+@pytest.mark.asyncio
+async def test_return_type_validation_failure():
+    payload = {"id": 5, "method": "invalid_return", "params": {}}
+    response = await handle_request(payload, router=router)
+    assert response["error"]["code"] == -32603
+    assert "Return type validation failed" in response["error"]["message"]
+
+@pytest.mark.asyncio
+async def test_router_merging():
+    sub_router = Router()
+    @sub_router.rpc
+    def sub_func(): return "sub"
+    
+    main_router = Router()
+    main_router.merge(sub_router, prefix="test.")
+    
+    # Check if sub_func is accessible via prefix
+    payload = {"id": 6, "method": "test.sub_func", "params": {}}
+    response = await handle_request(payload, router=main_router)
+    assert response["result"] == "sub"
+
+@pytest.mark.asyncio
+async def test_method_not_found():
+    payload = {"id": 7, "method": "non_existent", "params": {}}
+    response = await handle_request(payload, router=router)
+    assert response["error"]["code"] == -32601

pyrpc_core-0.1.0a1/tests/test_transport.py

@@ -0,0 +1,96 @@
+import pytest
+from typing import List, Optional
+from pydantic import BaseModel
+from pyrpc_core.core.registry import Router, Procedure
+from pyrpc_core.core.introspection import get_procedure_schema, get_registry_schema
+from pyrpc_core.transport.asgi import PyRPCAsgiApp
+import json
+
+# --- Introspection Tests ---
+
+class User(BaseModel):
+    id: int
+    name: str
+
+def test_procedure_introspection():
+    def my_func(user: User, tags: List[str]) -> bool:
+        """My docstring"""
+        return True
+    
+    proc = Procedure(my_func)
+    schema = get_procedure_schema(proc)
+    assert schema.name == "my_func"
+    assert schema.doc == "My docstring"
+    assert schema.return_type == "<class 'bool'>"
+    
+    # Check parameters
+    params = {p.name: p for p in schema.parameters}
+    assert "user" in params
+    assert params["user"].schema_["properties"]["id"]["type"] == "integer"
+    assert "tags" in params
+    assert params["tags"].schema_["type"] == "array"
+
+def test_registry_introspection():
+    router = Router()
+    @router.rpc
+    def add(a: int, b: int): pass
+    
+    schemas = get_registry_schema(router)
+    assert "add" in schemas
+    assert len(schemas["add"].parameters) == 2
+
+# --- ASGI Transport Tests ---
+
+@pytest.mark.asyncio
+async def test_asgi_app_basic():
+    router = Router()
+    @router.rpc
+    def hello(): return "world"
+    
+    app = PyRPCAsgiApp(router=router)
+    
+    # Mock ASGI interaction
+    scope = {
+        "type": "http",
+        "method": "POST",
+        "path": "/rpc"
+    }
+    
+    sent_messages = []
+    
+    async def mock_receive():
+        return {
+            "type": "http.request",
+            "body": json.dumps({"id": 1, "method": "hello", "params": {}}).encode("utf-8"),
+            "more_body": False
+        }
+        
+    async def mock_send(message):
+        sent_messages.append(message)
+        
+    await app(scope, mock_receive, mock_send)
+    
+    # Verify response
+    # 1. Start message
+    assert sent_messages[0]["type"] == "http.response.start"
+    assert sent_messages[0]["status"] == 200
+    
+    # 2. Body message
+    assert sent_messages[1]["type"] == "http.response.body"
+    res_payload = json.loads(sent_messages[1]["body"].decode("utf-8"))
+    assert res_payload["result"] == "world"
+
+@pytest.mark.asyncio
+async def test_asgi_app_404():
+    app = PyRPCAsgiApp()
+    scope = {
+        "type": "http",
+        "method": "GET",
+        "path": "/wrong"
+    }
+    
+    sent_messages = []
+    async def mock_send(message): sent_messages.append(message)
+    
+    await app(scope, None, mock_send)
+    assert sent_messages[0]["status"] == 404