mcp-proxy-adapter 3.1.5__py3-none-any.whl → 4.0.0__py3-none-any.whl

examples/basic_example/tests/conftest.py

@@ -1,243 +0,0 @@
-"""
-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/check_vstl_schema.py

@@ -1,106 +0,0 @@
-#!/usr/bin/env python3
-"""
-Скрипт для проверки схемы команды help в сервисе VSTL
-"""
-
-import json
-import requests
-from typing import Dict, Any, Optional
-
-# URL и заголовки для VSTL сервиса
-VSTL_URL = "http://localhost:8007/cmd"
-HEADERS = {"Content-Type": "application/json"}
-
-def send_json_rpc(method: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-    """
-    Отправляет JSON-RPC запрос и возвращает ответ
-    
-    Args:
-        method: Имя метода
-        params: Параметры запроса
-        
-    Returns:
-        Dict[str, Any]: Ответ сервера
-    """
-    # Формируем JSON-RPC запрос
-    payload = {
-        "jsonrpc": "2.0",
-        "method": method,
-        "id": 1
-    }
-    
-    # Добавляем параметры, если они есть
-    if params is not None:
-        payload["params"] = params
-    
-    print(f"Отправляем запрос: {json.dumps(payload, indent=2)}")
-    
-    # Отправляем запрос
-    response = requests.post(VSTL_URL, json=payload, headers=HEADERS)
-    
-    # Возвращаем ответ
-    return response.json()
-
-def test_help_command():
-    """
-    Проверяет команду help в различных вариантах
-    """
-    print("\n=== Проверка команды help без параметров ===")
-    response = send_json_rpc("help")
-    print(f"Ответ: {json.dumps(response, indent=2)}")
-    
-    print("\n=== Проверка команды help с пустыми параметрами ===")
-    response = send_json_rpc("help", {})
-    print(f"Ответ: {json.dumps(response, indent=2)}")
-    
-    print("\n=== Проверка команды help с параметром cmdname=null ===")
-    response = send_json_rpc("help", {"cmdname": None})
-    print(f"Ответ: {json.dumps(response, indent=2)}")
-    
-    print("\n=== Проверка команды help с параметром cmdname=\"config\" ===")
-    response = send_json_rpc("help", {"cmdname": "config"})
-    print(f"Ответ: {json.dumps(response, indent=2)}")
-    
-    # Проверяем workaround с передачей строки "null"
-    print("\n=== Проверка команды help с параметром cmdname=\"null\" ===")
-    response = send_json_rpc("help", {"cmdname": "null"})
-    print(f"Ответ: {json.dumps(response, indent=2)}")
-
-def check_schema():
-    """
-    Проверяет схему команд и ищет обязательные параметры
-    """
-    print("\n=== Проверка схемы команд ===")
-    
-    # Запрашиваем список всех доступных команд
-    health_response = send_json_rpc("health")
-    print(f"Здоровье сервиса: {json.dumps(health_response, indent=2)}")
-    
-    # Проверяем команду config для получения схемы
-    config_response = send_json_rpc("config", {"operation": "get"})
-    print(f"Конфигурация: {json.dumps(config_response, indent=2)}")
-    
-    # Пробуем с явным указанием строки вместо null
-    print("\n=== Проверка команды help с cmdname=\"\" (пустая строка) ===")
-    response = send_json_rpc("help", {"cmdname": ""})
-    print(f"Ответ: {json.dumps(response, indent=2)}")
-    
-    # Создаем свой вариант с переопределением параметров
-    print("\n=== Проверка специального запроса с kwargs=null ===")
-    # Прямая отправка JSON с null значением для kwargs
-    special_payload = {
-        "jsonrpc": "2.0",
-        "method": "help",
-        "params": {"kwargs": None},
-        "id": 1
-    }
-    response = requests.post(VSTL_URL, json=special_payload, headers=HEADERS)
-    print(f"Ответ: {json.dumps(response.json(), indent=2)}")
-
-if __name__ == "__main__":
-    print("=== Диагностика проблемы с командой help в сервисе VSTL ===")
-    try:
-        test_help_command()
-        check_schema()
-    except Exception as e:
-        print(f"Ошибка при выполнении: {e}") 

examples/commands/echo_command.py

@@ -1,52 +0,0 @@
-"""
-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_command_di.py

@@ -1,152 +0,0 @@
-"""
-Example command with dependency injection.
-
-This module demonstrates how to use dependency injection in commands.
-"""
-
-from typing import Any, Dict, List, Optional
-
-from mcp_proxy_adapter.commands import Command, SuccessResult
-from mcp_proxy_adapter.commands.result import CommandResult
-
-
-class EchoCommandResult(SuccessResult):
-    """
-    Result of echo command execution.
-    """
-    
-    def __init__(self, message: str, timestamp: str, **kwargs):
-        """
-        Initializes echo command result.
-        
-        Args:
-            message: Echoed message
-            timestamp: Time of execution
-            **kwargs: Additional parameters
-        """
-        data = {"message": message, "timestamp": timestamp}
-        data.update(kwargs)
-        super().__init__(data=data, message=f"Echo response: {message}")
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Returns JSON schema for result validation.
-        
-        Returns:
-            Dictionary with JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "success": {"type": "boolean"},
-                "data": {
-                    "type": "object",
-                    "properties": {
-                        "message": {"type": "string"},
-                        "timestamp": {"type": "string", "format": "date-time"}
-                    },
-                    "required": ["message", "timestamp"]
-                },
-                "message": {"type": "string"}
-            },
-            "required": ["success", "data"]
-        }
-
-
-class TimeService:
-    """
-    Service for time-related operations.
-    
-    This is a dependency that will be injected into the EchoCommand.
-    """
-    
-    def get_current_time(self) -> str:
-        """
-        Get current time formatted as ISO string.
-        
-        Returns:
-            Current time as ISO formatted string
-        """
-        from datetime import datetime
-        return datetime.now().isoformat()
-
-
-class EchoCommand(Command):
-    """
-    Command that echoes back a message with timestamp.
-    
-    This command demonstrates how to use dependency injection in commands
-    by accepting a service dependency in the constructor.
-    """
-    
-    # Command name for JSON-RPC endpoint
-    name = "echo_di"
-    # Command result class
-    result_class = EchoCommandResult
-    
-    def __init__(self, time_service: TimeService):
-        """
-        Initialize command with dependencies.
-        
-        Args:
-            time_service: Service for getting the current time
-        """
-        self.time_service = time_service
-    
-    async def execute(self, message: str = "Hello, World!") -> CommandResult:
-        """
-        Executes echo command.
-        
-        Args:
-            message: Message to echo back
-            
-        Returns:
-            Command execution result with message and timestamp
-        """
-        timestamp = self.time_service.get_current_time()
-        return EchoCommandResult(message=message, timestamp=timestamp)
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Returns JSON schema for command parameters validation.
-        
-        Returns:
-            Dictionary with JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "message": {
-                    "type": "string",
-                    "description": "Message to echo back"
-                }
-            },
-            "additionalProperties": False
-        }
-
-
-# Example of registering the command with dependency injection
-def register_echo_command():
-    """
-    Register echo command with dependencies.
-    
-    This function shows how to:
-    1. Create a service dependency
-    2. Create a command instance with the dependency
-    3. Register the command instance in the registry
-    """
-    from mcp_proxy_adapter.commands import registry, container
-    
-    # Create and register service in the container
-    time_service = TimeService()
-    container.register("time_service", time_service)
-    
-    # Create command with dependencies
-    echo_command = EchoCommand(time_service)
-    
-    # Register command instance
-    registry.register(echo_command)
-    
-    return echo_command 

examples/commands/echo_result.py

@@ -1,65 +0,0 @@
-"""
-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", {})
-        )