mcp-proxy-adapter 2.1.17__py3-none-any.whl → 3.0.1__py3-none-any.whl

examples/basic_example/tests/conftest.py

@@ -0,0 +1,243 @@
+"""
+Pytest configuration and fixtures for basic example tests.
+
+This module provides fixtures for testing the basic microservice example,
+including running an actual server instance for integration tests.
+All commands in the microservice are implemented as asynchronous functions.
+"""
+
+import os
+import sys
+import time
+import socket
+import asyncio
+import threading
+import multiprocessing
+from typing import Callable, Dict, Any, List
+
+import pytest
+import requests
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Import the server module from the parent directory
+import server as server_module
+from commands.echo_command import EchoCommand
+from commands.math_command import MathCommand
+from commands.time_command import TimeCommand
+
+
+def find_free_port() -> int:
+    """
+    Find a free port on localhost.
+    
+    Returns:
+        Free port number
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(('localhost', 0))
+        return sock.getsockname()[1]
+
+
+class ServerProcess:
+    """Helper class to manage server process."""
+    
+    def __init__(self, port: int):
+        """
+        Initialize server process with a specified port.
+        
+        Args:
+            port: Port number to use
+        """
+        self.port = port
+        self.process = None
+        
+    def start(self) -> None:
+        """Start the server in a separate process."""
+        def run_server():
+            # Mock the configuration to use the test port
+            os.environ["TEST_SERVER_PORT"] = str(self.port)
+            server_module.main()
+            
+        self.process = multiprocessing.Process(target=run_server)
+        self.process.daemon = True
+        self.process.start()
+        
+        # Wait for server to start
+        self._wait_for_server()
+        
+    def stop(self) -> None:
+        """Stop the server process."""
+        if self.process and self.process.is_alive():
+            self.process.terminate()
+            self.process.join(timeout=2)
+            
+    def _wait_for_server(self, max_attempts: int = 10) -> None:
+        """
+        Wait for the server to become available.
+        
+        Args:
+            max_attempts: Maximum number of connection attempts
+        """
+        for i in range(max_attempts):
+            try:
+                response = requests.get(f"http://localhost:{self.port}/health")
+                if response.status_code == 200:
+                    return
+            except requests.ConnectionError:
+                pass
+            
+            time.sleep(0.5)
+            
+        raise TimeoutError(f"Server did not start within {max_attempts * 0.5} seconds")
+
+
+@pytest.fixture
+def server_port() -> int:
+    """
+    Fixture that provides a free port for the test server.
+    
+    Returns:
+        Port number
+    """
+    return find_free_port()
+
+
+@pytest.fixture
+def server(server_port: int) -> ServerProcess:
+    """
+    Fixture that provides a running server instance.
+    
+    Args:
+        server_port: Port to run the server on
+    
+    Returns:
+        Server process object
+    """
+    server_process = ServerProcess(server_port)
+    server_process.start()
+    
+    yield server_process
+    
+    server_process.stop()
+
+
+@pytest.fixture
+def api_url(server_port: int) -> str:
+    """
+    Fixture that provides the base API URL.
+    
+    Args:
+        server_port: Server port
+        
+    Returns:
+        Base API URL
+    """
+    return f"http://localhost:{server_port}"
+
+
+@pytest.fixture
+def jsonrpc_client(api_url: str) -> Callable:
+    """
+    Fixture that provides a JSON-RPC client function.
+    
+    Args:
+        api_url: Base API URL
+        
+    Returns:
+        Function to make JSON-RPC requests
+    """
+    def make_request(method: str, params: Dict[str, Any], request_id: int = 1) -> Dict[str, Any]:
+        """
+        Make a JSON-RPC request.
+        
+        Args:
+            method: Method name
+            params: Method parameters
+            request_id: Request ID
+            
+        Returns:
+            JSON-RPC response
+        """
+        payload = {
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params,
+            "id": request_id
+        }
+        
+        response = requests.post(
+            f"{api_url}/api/jsonrpc",
+            json=payload,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        return response.json()
+    
+    return make_request
+
+
+@pytest.fixture
+def batch_jsonrpc_client(api_url: str) -> Callable:
+    """
+    Fixture that provides a batch JSON-RPC client function.
+    
+    Args:
+        api_url: Base API URL
+        
+    Returns:
+        Function to make batch JSON-RPC requests
+    """
+    def make_batch_request(requests_data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        Make a batch JSON-RPC request.
+        
+        Args:
+            requests_data: List of request objects
+            
+        Returns:
+            List of JSON-RPC responses
+        """
+        response = requests.post(
+            f"{api_url}/api/jsonrpc",
+            json=requests_data,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        return response.json()
+    
+    return make_batch_request
+
+
+@pytest.fixture
+def echo_command() -> EchoCommand:
+    """
+    Fixture that provides an instance of EchoCommand.
+    
+    Returns:
+        EchoCommand instance
+    """
+    return EchoCommand()
+
+
+@pytest.fixture
+def math_command() -> MathCommand:
+    """
+    Fixture that provides an instance of MathCommand.
+    
+    Returns:
+        MathCommand instance
+    """
+    return MathCommand()
+
+
+@pytest.fixture
+def time_command() -> TimeCommand:
+    """
+    Fixture that provides an instance of TimeCommand.
+    
+    Returns:
+        TimeCommand instance
+    """
+    return TimeCommand() 

examples/commands/echo_command.py

@@ -0,0 +1,52 @@
+"""
+Module with echo command implementation.
+"""
+
+from typing import Any, Dict, Optional, ClassVar, Type
+
+from pydantic import BaseModel, Field, ValidationError as PydanticValidationError
+
+from mcp_proxy_adapter.commands.base import Command
+from examples.commands.echo_result import EchoResult
+from mcp_proxy_adapter.core.errors import ValidationError
+from mcp_proxy_adapter.core.logging import logger
+
+
+class EchoCommand(Command):
+    """
+    Command that echoes back the parameters it receives.
+    
+    This command is useful for testing parameter passing and debugging.
+    """
+    
+    name: ClassVar[str] = "echo"
+    result_class: ClassVar[Type[EchoResult]] = EchoResult
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Returns JSON schema for command parameters validation.
+        
+        Returns:
+            Dictionary with JSON schema.
+        """
+        return {
+            "type": "object",
+            "additionalProperties": True,
+            "description": "Any parameters will be echoed back in the response"
+        }
+    
+    async def execute(self, **kwargs) -> EchoResult:
+        """
+        Executes echo command and returns the parameters back.
+        
+        Args:
+            **kwargs: Any parameters to echo back.
+            
+        Returns:
+            EchoResult: Command execution result with the parameters.
+        """
+        logger.debug(f"Echo command received parameters: {kwargs}")
+        
+        # Simply return the parameters that were passed
+        return EchoResult(params=kwargs) 

examples/commands/echo_result.py

@@ -0,0 +1,65 @@
+"""
+Module with result class for echo command.
+"""
+
+from typing import Any, Dict, ClassVar, Type
+from pydantic import BaseModel, Field
+
+from mcp_proxy_adapter.commands.result import CommandResult
+
+
+class EchoResult(CommandResult, BaseModel):
+    """
+    Result of echo command execution.
+    
+    Attributes:
+        params (Dict[str, Any]): Parameters that were passed to the command.
+    """
+    
+    params: Dict[str, Any] = Field(..., description="Parameters that were passed to the command")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Converts result to dictionary for serialization.
+
+        Returns:
+            Dictionary with result data.
+        """
+        return {
+            "params": self.params
+        }
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Returns JSON schema for result validation.
+
+        Returns:
+            Dictionary with JSON schema.
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "params": {
+                    "type": "object", 
+                    "description": "Parameters that were passed to the command",
+                    "additionalProperties": True
+                }
+            },
+            "required": ["params"]
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "EchoResult":
+        """
+        Creates result instance from dictionary.
+
+        Args:
+            data: Dictionary with result data.
+
+        Returns:
+            EchoResult instance.
+        """
+        return cls(
+            params=data.get("params", {})
+        ) 

examples/commands/get_date_command.py

@@ -0,0 +1,98 @@
+"""
+Module for the get_date command implementation.
+"""
+
+from datetime import datetime
+from typing import Any, Dict
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.core.logging import logger
+
+
+class GetDateResult(CommandResult):
+    """Result of getting current date"""
+    
+    def __init__(self, date: str):
+        """
+        Initialize the GetDateResult.
+        
+        Args:
+            date: Date in ISO 8601 format
+        """
+        self.date = date
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the result to a dictionary.
+        
+        Returns:
+            Dictionary with the date
+        """
+        return {"date": self.date}
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get the JSON schema for this result.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "required": ["date"],
+            "properties": {
+                "date": {
+                    "type": "string",
+                    "description": "Current date and time in ISO 8601 format",
+                    "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}[+-]\\d{2}:?\\d{2}$"
+                }
+            }
+        }
+
+
+class GetDateCommand(Command):
+    """
+    Command that returns the current date and time in ISO 8601 format.
+    """
+    
+    name = "get_date"
+    
+    async def execute(self) -> GetDateResult:
+        """
+        Execute the get_date command.
+        
+        Returns:
+            GetDateResult: Result with date in ISO 8601 format
+        """
+        # Get current time with timezone info
+        now = datetime.now().astimezone()
+        
+        # Format to ISO 8601
+        date_str = now.strftime("%Y-%m-%dT%H:%M:%S%z")
+        
+        # Insert colon in timezone offset (e.g. +0300 -> +03:00)
+        if len(date_str) >= 6:
+            date_str = date_str[:-2] + ":" + date_str[-2:]
+            
+        logger.debug(f"Generated date: {date_str}")
+        return GetDateResult(date=date_str)
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get the JSON schema for this command.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {}
+        }
+
+
+# Register the command
+registry.register(GetDateCommand) 

examples/commands/new_uuid4_command.py

@@ -0,0 +1,91 @@
+"""
+Module for the new_uuid4 command implementation.
+"""
+
+import uuid
+from typing import Any, Dict
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.core.logging import logger
+
+
+class NewUuid4Result(CommandResult):
+    """Result of UUID4 generation"""
+    
+    def __init__(self, uuid_str: str):
+        """
+        Initialize the NewUuid4Result.
+        
+        Args:
+            uuid_str: UUID in string format
+        """
+        self.uuid = uuid_str
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the result to a dictionary.
+        
+        Returns:
+            Dictionary with the UUID
+        """
+        return {"uuid": self.uuid}
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get the JSON schema for this result.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "required": ["uuid"],
+            "properties": {
+                "uuid": {
+                    "type": "string",
+                    "description": "Generated UUID4 in string format",
+                    "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
+                }
+            }
+        }
+
+
+class NewUuid4Command(Command):
+    """
+    Command that generates a new UUID version 4 (random).
+    """
+    
+    name = "new_uuid4"
+    
+    async def execute(self) -> NewUuid4Result:
+        """
+        Execute the new_uuid4 command.
+        
+        Returns:
+            NewUuid4Result: Result with UUID in string format
+        """
+        # Generate a UUID4
+        uuid_str = str(uuid.uuid4())
+        
+        logger.debug(f"Generated UUID4: {uuid_str}")
+        return NewUuid4Result(uuid_str=uuid_str)
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get the JSON schema for this command.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {}
+        }
+
+
+# Register the command
+registry.register(NewUuid4Command) 

examples/complete_example/Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create necessary directories
+RUN mkdir -p /app/logs /app/cache /app/data
+
+# Copy application files
+COPY . .
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV CONFIG_PATH=/app/configs/config.docker.yaml
+
+# Expose API port
+EXPOSE 8000
+
+# Run the application
+CMD ["python", "server.py", "--config", "/app/configs/config.docker.yaml"] 

examples/complete_example/README.md

@@ -0,0 +1,92 @@
+# Complete MCP Proxy Adapter Example
+
+This example demonstrates a complete MCP Proxy Adapter application with Docker support,
+environment-specific configuration, and multiple commands.
+
+## Structure
+
+```
+complete_example/
+├── cache/                     # Cache directory
+├── commands/                  # Commands directory
+│   ├── __init__.py           # Package initialization
+│   ├── db_command.py         # Database command
+│   ├── file_command.py       # File operations command
+│   └── system_command.py     # System information command
+├── configs/                   # Configuration files
+│   ├── config.dev.yaml       # Development config
+│   └── config.docker.yaml    # Docker config
+├── docker-compose.yml        # Docker Compose file
+├── Dockerfile                # Docker image definition
+├── logs/                     # Logs directory
+├── README.md                 # This documentation file
+├── requirements.txt          # Python dependencies
+└── server.py                 # Server startup file
+```
+
+## Features
+
+- Multiple commands in separate files
+- Environment-specific configuration
+- Docker support
+- Volume mounting for logs, cache, and config
+- Network configuration
+
+## Running Locally
+
+```bash
+# Navigate to the project directory
+cd examples/complete_example
+
+# Create virtual environment (optional)
+python -m venv venv
+source venv/bin/activate  # Linux/Mac
+# or
+# venv\Scripts\activate  # Windows
+
+# Install dependencies
+pip install -r requirements.txt
+pip install -e ../..  # Install mcp_proxy_adapter from parent directory
+
+# Run the server with development config
+python server.py --config configs/config.dev.yaml
+```
+
+The server will be available at [http://localhost:8000](http://localhost:8000).
+
+## Running with Docker
+
+```bash
+# Navigate to the project directory
+cd examples/complete_example
+
+# Build the Docker image
+docker build -t mcp-proxy-adapter-example .
+
+# Run with Docker Compose
+docker-compose up
+```
+
+The server will be available at [http://localhost:8000](http://localhost:8000).
+
+## Available Commands
+
+The microservice includes several commands that demonstrate different features:
+
+1. `system_info` - Returns system information
+2. `file_operations` - Performs file operations
+3. `db_query` - Executes database queries
+
+For details on each command, see the API documentation at [http://localhost:8000/docs](http://localhost:8000/docs)
+when the server is running.
+
+## Docker Configuration
+
+The Docker setup includes:
+
+- Volume mounts for logs, cache, and configuration
+- Network configuration for integration with other services
+- User mapping to avoid permission issues
+- Port forwarding
+
+For details, see the `docker-compose.yml` file. 

examples/complete_example/__init__.py

@@ -0,0 +1,8 @@
+"""
+Complete example for MCP Microservice.
+
+This package contains a complete example of using MCP Microservice framework
+with Docker support, multiple commands, configuration management, and tests.
+"""
+
+__all__ = [] 

examples/complete_example/commands/__init__.py

@@ -0,0 +1,5 @@
+"""
+Command package for complete example.
+
+This package contains all commands for the complete microservice example.
+"""