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

examples/minimal_example/README.md

@@ -1,65 +0,0 @@
-# Минимальный пример MCP Proxy Adapter
-
-Данный пример демонстрирует минимальную конфигурацию для запуска микросервиса с одной простой командой.
-
-## Структура примера
-
-```
-minimal_example/
-├── config.json            # Файл конфигурации в JSON формате
-├── README.md              # Документация
-├── simple_server.py       # Пример сервера с одной командой
-└── tests/                 # Директория с интеграционными тестами
-    ├── conftest.py        # Настройка тестов
-    └── test_integration.py # Интеграционные тесты
-```
-
-## Запуск примера
-
-```bash
-# Перейти в директорию проекта
-cd examples/minimal_example
-
-# Запустить сервер
-python simple_server.py
-```
-
-После запуска сервер будет доступен по адресу [http://localhost:8000](http://localhost:8000).
-
-## Тестирование API
-
-### Через веб-интерфейс
-
-Откройте в браузере [http://localhost:8000/docs](http://localhost:8000/docs) для доступа к интерактивной документации Swagger UI.
-
-### Через командную строку
-
-```bash
-# Вызов команды hello через JSON-RPC
-curl -X POST "http://localhost:8000/api/jsonrpc" \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc": "2.0", "method": "hello", "params": {"name": "User"}, "id": 1}'
-
-# Вызов команды hello через упрощенный эндпоинт
-curl -X POST "http://localhost:8000/cmd" \
-  -H "Content-Type: application/json" \
-  -d '{"command": "hello", "params": {"name": "User"}}'
-```
-
-### Запуск интеграционных тестов
-
-```bash
-# Запуск всех тестов
-pytest tests/test_integration.py -v
-
-# Запуск конкретного теста
-pytest tests/test_integration.py::TestHelloCommandIntegration::test_jsonrpc_hello_default -v
-```
-
-## Что демонстрирует этот пример
-
-1. Создание минимального сервиса с MCP Proxy Adapter
-2. Определение простой команды с метаданными
-3. Основные эндпоинты API
-4. Работа с JSON-RPC
-5. Тестирование API через интеграционные тесты 

examples/minimal_example/__init__.py

@@ -1,8 +0,0 @@
-"""
-Minimal example for MCP Microservice.
-
-This package contains a minimal example of using MCP Microservice framework
-with a single echo command.
-"""
-
-__all__ = [] 

examples/minimal_example/config.json

@@ -1,14 +0,0 @@
-{
-  "server": {
-    "host": "0.0.0.0",
-    "port": 8000,
-    "debug": true,
-    "log_level": "INFO"
-  },
-  "logging": {
-    "level": "info",
-    "file": null,
-    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-  },
-  "debug": true
-}

examples/minimal_example/main.py

@@ -1,136 +0,0 @@
-"""
-Минимальный пример приложения MCP Proxy Adapter.
-"""
-
-import os
-import sys
-import uvicorn
-import logging
-import json
-from pathlib import Path
-
-from mcp_proxy_adapter import create_app, Command, SuccessResult
-from mcp_proxy_adapter.commands.command_registry import registry
-from mcp_proxy_adapter.core.logging import logger
-from mcp_proxy_adapter.config import config
-
-
-class HelloCommand(Command):
-    """Простая команда, возвращающая приветствие."""
-    
-    name = "hello"
-    
-    async def execute(self, name: str = "World") -> SuccessResult:
-        """Выполняет команду с переданным именем."""
-        logger.info(f"Executing hello command with name: {name}")
-        return SuccessResult({"message": f"Hello, {name}!"})
-
-
-def ensure_config():
-    """Проверяет наличие конфигурационного файла и создает его при необходимости."""
-    config_path = Path("config.json")
-    
-    if not config_path.exists():
-        config_data = {
-            "server": {
-                "host": "0.0.0.0",
-                "port": 8000,
-                "debug": True,
-                "log_level": "INFO"
-            },
-            "logging": {
-                "level": "info",
-                "file": "logs/minimal_example.log",
-                "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-            },
-            "debug": True
-        }
-        
-        # Создаем директорию для логов
-        logs_dir = Path("logs")
-        logs_dir.mkdir(exist_ok=True)
-        
-        # Записываем конфигурацию
-        with open(config_path, "w") as f:
-            json.dump(config_data, f, indent=2)
-        
-        logger.info(f"Created default configuration at {config_path}")
-
-
-def setup_application():
-    """
-    Настраивает и возвращает FastAPI приложение.
-    """
-    # Проверяем наличие конфигурационного файла
-    ensure_config()
-    
-    # Определяем путь к конфигурационному файлу
-    config_path = Path("config.json").absolute()
-    
-    # Загружаем конфигурацию из файла
-    if config_path.exists():
-        config.load_from_file(str(config_path))
-        logger.info(f"Loaded configuration from {config_path}")
-    
-    # Создаем приложение
-    app = create_app()
-    
-    # Корректно регистрируем команду
-    try:
-        # Проверяем, есть ли уже команда в реестре
-        if registry.command_exists(HelloCommand.name):
-            # Если команда существует, удаляем ее
-            logger.info(f"Command '{HelloCommand.name}' already exists, re-registering it")
-            registry.unregister(HelloCommand.name)
-        
-        # Регистрируем команду
-        registry.register(HelloCommand)
-        logger.info(f"Command '{HelloCommand.name}' successfully registered")
-        
-        # Выводим список всех зарегистрированных команд
-        commands = registry.get_all_commands()
-        logger.info(f"Total registered commands: {len(commands)}")
-    except Exception as e:
-        logger.error(f"Error registering command: {e}")
-    
-    return app
-
-
-def main():
-    """
-    Основная функция для запуска приложения.
-    """
-    try:
-        # Настраиваем приложение
-        app = setup_application()
-        
-        # Получаем настройки сервера из конфигурации
-        host = config.get("server.host", "0.0.0.0")
-        port = config.get("server.port", 8000)
-        debug = config.get("server.debug", False)
-        
-        logger.info(f"Starting server on {host}:{port} (debug: {debug})")
-        
-        if debug:
-            # В режиме отладки запускаем с перезагрузкой, используя строку импорта
-            uvicorn.run(
-                "main:setup_application",
-                host=host,
-                port=port,
-                reload=True,
-                factory=True
-            )
-        else:
-            # В обычном режиме запускаем экземпляр приложения
-            uvicorn.run(
-                app,
-                host=host,
-                port=port
-            )
-    except Exception as e:
-        logger.exception(f"Error during application startup: {e}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

examples/minimal_example/simple_server.py

@@ -1,163 +0,0 @@
-"""
-Минимальный пример использования MCP Proxy Adapter.
-
-Этот пример демонстрирует минимальную конфигурацию для запуска микросервиса
-с одной простой командой.
-"""
-
-import os
-import uvicorn
-from typing import Dict, Any, List
-
-from mcp_proxy_adapter import Command, SuccessResult, create_app, registry
-from mcp_proxy_adapter.core.logging import setup_logging
-from mcp_proxy_adapter.config import config
-
-
-class HelloResult(SuccessResult):
-    """
-    Результат выполнения команды hello.
-    
-    Атрибуты:
-        message (str): Приветственное сообщение
-    """
-    
-    def __init__(self, message: str):
-        """
-        Инициализация результата команды.
-        
-        Args:
-            message: Приветственное сообщение
-        """
-        self.message = message
-        
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Преобразование результата в словарь.
-        
-        Returns:
-            Словарь с результатом выполнения команды
-        """
-        return {"message": self.message}
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Получение JSON-схемы для результата.
-        
-        Returns:
-            JSON-схема результата
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "message": {"type": "string", "description": "Приветственное сообщение"}
-            },
-            "required": ["message"]
-        }
-
-
-class HelloCommand(Command):
-    """
-    Команда, возвращающая приветственное сообщение.
-    
-    Эта команда принимает имя пользователя и возвращает приветственное сообщение.
-    """
-    
-    # Имя команды для регистрации
-    name = "hello"
-    # Класс результата команды
-    result_class = HelloResult
-    
-    async def execute(self, name: str = "World") -> HelloResult:
-        """
-        Выполнение команды.
-        
-        Args:
-            name: Имя для приветствия (по умолчанию "World")
-            
-        Returns:
-            Результат выполнения команды с приветственным сообщением
-        """
-        return HelloResult(f"Hello, {name}!")
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Получение JSON-схемы для параметров команды.
-        
-        Returns:
-            JSON-схема параметров команды
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "name": {
-                    "type": "string",
-                    "description": "Имя для приветствия"
-                }
-            },
-            "additionalProperties": False
-        }
-    
-    @classmethod
-    def _generate_examples(cls, params: Dict[str, Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """
-        Генерирует примеры использования команды.
-        
-        Args:
-            params: Информация о параметрах команды
-            
-        Returns:
-            Список примеров
-        """
-        return [
-            {
-                "command": "hello",
-                "description": "Приветствие по умолчанию"
-            },
-            {
-                "command": "hello",
-                "params": {"name": "User"},
-                "description": "Приветствие с указанным именем"
-            }
-        ]
-
-
-def main():
-    """Запуск микросервиса."""
-    # Определяем путь к конфигурационному файлу
-    current_dir = os.path.dirname(os.path.abspath(__file__))
-    config_path = os.path.join(current_dir, "config.json")
-    
-    # Загружаем конфигурацию, если файл существует
-    if os.path.exists(config_path):
-        config.load_from_file(config_path)
-    
-    # Настраиваем логирование
-    setup_logging("INFO")
-    
-    # Создаем приложение FastAPI
-    app = create_app()
-    app.title = "Minimal Example"
-    app.description = "Минимальный пример использования MCP Proxy Adapter"
-    app.version = "1.0.0"
-    
-    # Регистрируем команду
-    registry.register(HelloCommand)
-    
-    # Определяем порт из переменной окружения или используем 8000 по умолчанию
-    port = int(os.environ.get("TEST_SERVER_PORT", 8000))
-    
-    # Запускаем сервер
-    uvicorn.run(
-        app,
-        host="0.0.0.0",
-        port=port,
-        reload=False,  # Отключаем автоперезагрузку для тестов
-        log_level="info"
-    )
-
-
-if __name__ == "__main__":
-    main() 

examples/minimal_example/tests/conftest.py

@@ -1,171 +0,0 @@
-"""
-Pytest configuration and fixtures for minimal example tests.
-"""
-
-import os
-import sys
-import time
-import socket
-import asyncio
-import threading
-import multiprocessing
-from typing import Callable, Tuple, Dict, Any
-
-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 simple_server
-
-
-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():
-            # Set the test port via environment variable
-            os.environ["TEST_SERVER_PORT"] = str(self.port)
-            simple_server.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 

examples/minimal_example/tests/test_hello_command.py

@@ -1,111 +0,0 @@
-"""
-Unit tests for the HelloCommand in the minimal example.
-"""
-
-import pytest
-
-from simple_server import HelloCommand, HelloResult
-
-
-class TestHelloCommand:
-    """Tests for HelloCommand class."""
-    
-    @pytest.mark.asyncio
-    async def test_execute_with_default_name(self):
-        """Test HelloCommand.execute with default name parameter."""
-        # Create command instance
-        command = HelloCommand()
-        
-        # Execute command with default parameter
-        result = await command.execute()
-        
-        # Check result type
-        assert isinstance(result, HelloResult)
-        
-        # Check message content
-        assert result.message == "Hello, World!"
-        
-        # Check serialization
-        assert result.to_dict() == {"message": "Hello, World!"}
-    
-    @pytest.mark.asyncio
-    async def test_execute_with_custom_name(self):
-        """Test HelloCommand.execute with custom name parameter."""
-        # Create command instance
-        command = HelloCommand()
-        
-        # Execute command with custom parameter
-        result = await command.execute(name="Test")
-        
-        # Check result
-        assert isinstance(result, HelloResult)
-        assert result.message == "Hello, Test!"
-        
-        # Check serialization
-        assert result.to_dict() == {"message": "Hello, Test!"}
-    
-    @pytest.mark.asyncio
-    async def test_execute_with_empty_name(self):
-        """Test HelloCommand.execute with empty name parameter."""
-        # Create command instance
-        command = HelloCommand()
-        
-        # Execute command with empty parameter
-        result = await command.execute(name="")
-        
-        # Check result
-        assert isinstance(result, HelloResult)
-        assert result.message == "Hello, !"
-        
-        # Check serialization
-        assert result.to_dict() == {"message": "Hello, !"}
-
-
-class TestHelloResult:
-    """Tests for HelloResult class."""
-    
-    def test_init(self):
-        """Test HelloResult initialization."""
-        # Create result instance
-        result = HelloResult("Hello, Test!")
-        
-        # Check attributes
-        assert result.message == "Hello, Test!"
-    
-    def test_to_dict(self):
-        """Test HelloResult.to_dict method."""
-        # Create result instance
-        result = HelloResult("Hello, Test!")
-        
-        # Check serialization
-        assert result.to_dict() == {"message": "Hello, Test!"}
-    
-    def test_get_schema(self):
-        """Test HelloResult.get_schema method."""
-        # Get schema
-        schema = HelloResult.get_schema()
-        
-        # Check schema structure
-        assert schema["type"] == "object"
-        assert "properties" in schema
-        assert "message" in schema["properties"]
-        assert schema["properties"]["message"]["type"] == "string"
-        assert "required" in schema
-        assert "message" in schema["required"]
-        
-
-class TestHelloCommandSchema:
-    """Tests for HelloCommand schema."""
-    
-    def test_get_schema(self):
-        """Test HelloCommand.get_schema method."""
-        # Get schema
-        schema = HelloCommand.get_schema()
-        
-        # Check schema structure
-        assert schema["type"] == "object"
-        assert "properties" in schema
-        assert "name" in schema["properties"]
-        assert schema["properties"]["name"]["type"] == "string"
-        assert "additionalProperties" in schema
-        assert schema["additionalProperties"] is False