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

examples/minimal_example/README.md

@@ -0,0 +1,51 @@
+# Минимальный пример MCP Microservice
+
+Данный пример демонстрирует минимальную конфигурацию для запуска микросервиса с одной простой командой.
+
+## Структура примера
+
+```
+minimal_example/
+├── config.yaml            # Файл конфигурации
+├── README.md              # Документация
+└── simple_server.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"}}'
+```
+
+## Что демонстрирует этот пример
+
+1. Создание минимального микросервиса
+2. Определение простой команды
+3. Основные эндпоинты API
+4. Работа с JSON-RPC 

examples/minimal_example/__init__.py

@@ -0,0 +1,8 @@
+"""
+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

@@ -0,0 +1,21 @@
+{
+  "service": {
+    "name": "Minimal Example",
+    "version": "1.0.0"
+  },
+  "server": {
+    "host": "0.0.0.0",
+    "port": 8000,
+    "debug": true,
+    "log_level": "info"
+  },
+  "logging": {
+    "level": "INFO",
+    "file": "logs/minimal_example.log",
+    "rotation": {
+      "type": "size",
+      "max_bytes": 10485760,
+      "backup_count": 5
+    }
+  }
+} 

examples/minimal_example/config.yaml

@@ -0,0 +1,26 @@
+# Minimal Example Configuration
+
+service:
+  name: "Minimal Example"
+  version: "1.0.0"
+
+server:
+  host: "0.0.0.0"
+  port: 8000
+  debug: true
+  log_level: "info"
+
+# Uncomment and configure this section if you need authentication
+# auth:
+#   enabled: false
+#   secret_key: ""
+#   token_expiration: 3600  # seconds
+
+# Настройки логирования
+logging:
+  level: "INFO"      # Уровень логирования (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+  file: "logs/minimal_example.log"  # Файл для записи логов
+  rotation:
+    type: "size"     # Тип ротации логов (size, time)
+    max_bytes: 10485760  # Максимальный размер файла лога (10 МБ)
+    backup_count: 5  # Количество резервных копий 

examples/minimal_example/main.py

@@ -0,0 +1,67 @@
+"""
+Main application module.
+"""
+
+import os
+import sys
+import uvicorn
+import logging
+
+from mcp_proxy_adapter.api.app import app
+from mcp_proxy_adapter.config import config
+from mcp_proxy_adapter.core.logging import logger, setup_logging
+
+
+def main():
+    """
+    Main function to run the application.
+    """
+    # Убедимся что логирование настроено
+    logger.info("Initializing logging configuration")
+    
+    try:
+        # Получаем настройки логирования
+        log_level = config.get("logging.level", "INFO")
+        log_file = config.get("logging.file")
+        rotation_type = config.get("logging.rotation.type", "size")
+        
+        # Выводим информацию о настройках логирования
+        logger.info(f"Log level: {log_level}")
+        if log_file:
+            logger.info(f"Log file: {log_file}")
+            logger.info(f"Log rotation type: {rotation_type}")
+            
+            if rotation_type.lower() == "time":
+                when = config.get("logging.rotation.when", "D")
+                interval = config.get("logging.rotation.interval", 1)
+                logger.info(f"Log rotation: every {interval} {when}")
+            else:
+                max_bytes = config.get("logging.rotation.max_bytes", 10 * 1024 * 1024)
+                logger.info(f"Log rotation: when size reaches {max_bytes / (1024*1024):.1f} MB")
+                
+            backup_count = config.get("logging.rotation.backup_count", 5)
+            logger.info(f"Log backups: {backup_count}")
+        else:
+            logger.info("File logging is disabled")
+            
+        # Get server settings
+        host = config.get("server.host", "0.0.0.0")
+        port = config.get("server.port", 8000)
+        
+        logger.info(f"Starting server on {host}:{port}")
+        
+        # Run server
+        uvicorn.run(
+            app,
+            host=host,
+            port=port,
+            reload=True if os.environ.get("DEBUG") else False,
+            log_level=log_level.lower()
+        )
+    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

@@ -0,0 +1,124 @@
+"""
+Минимальный пример использования MCP Microservice.
+
+Этот пример демонстрирует минимальную конфигурацию для запуска микросервиса
+с одной простой командой.
+"""
+
+import os
+from typing import Dict, Any
+
+import mcp_proxy_adapter as mcp
+from mcp_proxy_adapter import Command, SuccessResult
+
+
+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
+        }
+
+
+def main():
+    """Запуск микросервиса."""
+    # Определяем путь к конфигурационному файлу
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    config_path = os.path.join(current_dir, "config.yaml")
+    
+    # Создаем микросервис
+    service = mcp.MicroService(
+        title="Minimal Example",
+        description="Минимальный пример использования MCP Microservice",
+        version="1.0.0",
+        config_path=config_path
+    )
+    
+    # Регистрируем команду
+    service.register_command(HelloCommand)
+    
+    # Запускаем сервер
+    service.run(reload=True)
+
+
+if __name__ == "__main__":
+    main() 

examples/minimal_example/tests/conftest.py

@@ -0,0 +1,171 @@
+"""
+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():
+            # Mock the configuration to use the test port
+            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

@@ -0,0 +1,111 @@
+"""
+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