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

examples/basic_example/README.md

@@ -0,0 +1,131 @@
+# Базовый пример MCP Microservice
+
+Этот пример демонстрирует базовую функциональность MCP Microservice с несколькими командами,
+организованными в отдельные файлы.
+
+## Структура примера
+
+```
+basic_example/
+├── commands/                   # Директория с командами
+│   ├── __init__.py            # Инициализация пакета команд
+│   ├── echo_command.py        # Команда эхо
+│   ├── math_command.py        # Математическая команда
+│   └── time_command.py        # Команда времени
+├── config.yaml                # Файл конфигурации
+├── README.md                  # Документация
+└── server.py                  # Файл запуска сервера
+```
+
+## Запуск примера
+
+```bash
+# Перейти в директорию проекта
+cd examples/basic_example
+
+# Создать директорию для логов, если она не существует
+mkdir -p logs
+
+# Запустить сервер
+python server.py
+```
+
+После запуска сервер будет доступен по адресу [http://localhost:8000](http://localhost:8000).
+
+## Доступные команды
+
+### 1. `echo` - Эхо-команда
+
+Возвращает переданное сообщение.
+
+**Параметры:**
+- `message` (string) - Сообщение для эхо
+
+**Пример запроса:**
+```json
+{
+  "jsonrpc": "2.0",
+  "method": "echo",
+  "params": {
+    "message": "Hello, World!"
+  },
+  "id": 1
+}
+```
+
+### 2. `math` - Математическая команда
+
+Выполняет математическую операцию над двумя числами.
+
+**Параметры:**
+- `a` (number) - Первое число
+- `b` (number) - Второе число
+- `operation` (string) - Операция (add, subtract, multiply, divide)
+
+**Пример запроса:**
+```json
+{
+  "jsonrpc": "2.0",
+  "method": "math",
+  "params": {
+    "a": 10,
+    "b": 5,
+    "operation": "add"
+  },
+  "id": 1
+}
+```
+
+### 3. `time` - Команда времени
+
+Возвращает текущее время и дату.
+
+**Параметры:**
+- `format` (string, optional) - Формат времени (default: "%Y-%m-%d %H:%M:%S")
+- `timezone` (string, optional) - Часовой пояс (default: "UTC")
+
+**Пример запроса:**
+```json
+{
+  "jsonrpc": "2.0",
+  "method": "time",
+  "params": {
+    "format": "%d.%m.%Y %H:%M:%S",
+    "timezone": "Europe/Moscow"
+  },
+  "id": 1
+}
+```
+
+## Тестирование API
+
+### Через веб-интерфейс
+
+Откройте в браузере [http://localhost:8000/docs](http://localhost:8000/docs) для доступа к интерактивной документации Swagger UI.
+
+### Через командную строку
+
+```bash
+# Вызов команды echo через JSON-RPC
+curl -X POST "http://localhost:8000/api/jsonrpc" \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc": "2.0", "method": "echo", "params": {"message": "Hello!"}, "id": 1}'
+
+# Вызов команды math через упрощенный эндпоинт
+curl -X POST "http://localhost:8000/cmd" \
+  -H "Content-Type: application/json" \
+  -d '{"command": "math", "params": {"a": 10, "b": 5, "operation": "add"}}'
+
+# Вызов команды time через endpoint /api/command/{command_name}
+curl -X POST "http://localhost:8000/api/command/time" \
+  -H "Content-Type: application/json" \
+  -d '{"format": "%d.%m.%Y %H:%M:%S", "timezone": "UTC"}'
+```
+
+## Что демонстрирует этот пример
+
+1. Организация команд в отдельные файлы
+2. Автоматическое обнаружение и регистрация команд
+3. Различные типы команд и параметров
+4. Обработка ошибок
+5. Различные способы вызова команд (JSON-RPC, /cmd, /api/command/{command_name}) 

examples/basic_example/__init__.py

@@ -0,0 +1,8 @@
+"""
+Basic example for MCP Microservice.
+
+This package contains a basic example of using MCP Microservice framework
+with several commands, separate command files, and tests.
+"""
+
+__all__ = [] 

examples/basic_example/commands/__init__.py

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

examples/basic_example/commands/echo_command.py

@@ -0,0 +1,95 @@
+"""
+Echo command module.
+
+This module contains a simple echo command that returns the input message.
+"""
+
+from typing import Dict, Any
+
+from mcp_proxy_adapter import Command, SuccessResult
+
+
+class EchoResult(SuccessResult):
+    """
+    Result of echo command.
+    
+    Attributes:
+        message (str): Echo message
+    """
+    
+    def __init__(self, message: str):
+        """
+        Initialize result.
+        
+        Args:
+            message: Message to echo back
+        """
+        self.message = message
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dictionary representation
+        """
+        return {"message": self.message}
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for result.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "message": {"type": "string", "description": "Echo message"}
+            },
+            "required": ["message"]
+        }
+
+
+class EchoCommand(Command):
+    """
+    Command that echoes back input message.
+    
+    This command demonstrates simple parameter handling.
+    """
+    
+    name = "echo"
+    result_class = EchoResult
+    
+    async def execute(self, message: str) -> EchoResult:
+        """
+        Execute command.
+        
+        Args:
+            message: Message to echo back
+            
+        Returns:
+            Echo result containing the input message
+        """
+        return EchoResult(message)
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "message": {
+                    "type": "string",
+                    "description": "Message to echo back"
+                }
+            },
+            "required": ["message"],
+            "additionalProperties": False
+        } 

examples/basic_example/commands/math_command.py

@@ -0,0 +1,151 @@
+"""
+Math command module.
+
+This module contains a command for performing math operations on two numbers.
+"""
+
+from typing import Dict, Any, Literal, Union
+
+from mcp_proxy_adapter import Command, SuccessResult, ErrorResult, InvalidParamsError
+
+
+class MathResult(SuccessResult):
+    """
+    Result of math command.
+    
+    Attributes:
+        result (float): Result of the math operation
+        operation (str): Operation that was performed
+        a (float): First operand
+        b (float): Second operand
+    """
+    
+    def __init__(self, result: float, operation: str, a: float, b: float):
+        """
+        Initialize result.
+        
+        Args:
+            result: Result of the operation
+            operation: Operation performed
+            a: First operand
+            b: Second operand
+        """
+        self.result = result
+        self.operation = operation
+        self.a = a
+        self.b = b
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dictionary representation
+        """
+        return {
+            "result": self.result,
+            "operation": self.operation,
+            "a": self.a,
+            "b": self.b
+        }
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for result.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "result": {"type": "number", "description": "Result of the operation"},
+                "operation": {"type": "string", "description": "Operation performed"},
+                "a": {"type": "number", "description": "First operand"},
+                "b": {"type": "number", "description": "Second operand"}
+            },
+            "required": ["result", "operation", "a", "b"]
+        }
+
+
+class MathCommand(Command):
+    """
+    Command that performs math operations.
+    
+    This command demonstrates parameter validation and error handling.
+    """
+    
+    name = "math"
+    result_class = MathResult
+    
+    async def execute(
+        self, 
+        a: float, 
+        b: float, 
+        operation: Literal["add", "subtract", "multiply", "divide"]
+    ) -> Union[MathResult, ErrorResult]:
+        """
+        Execute command.
+        
+        Args:
+            a: First number
+            b: Second number
+            operation: Math operation to perform (add, subtract, multiply, divide)
+            
+        Returns:
+            Math result containing the result of the operation
+            
+        Raises:
+            InvalidParamsError: If operation is invalid or division by zero
+        """
+        try:
+            if operation == "add":
+                result = a + b
+            elif operation == "subtract":
+                result = a - b
+            elif operation == "multiply":
+                result = a * b
+            elif operation == "divide":
+                if b == 0:
+                    raise InvalidParamsError("Division by zero is not allowed")
+                result = a / b
+            else:
+                raise InvalidParamsError(
+                    f"Invalid operation: {operation}. Must be one of: add, subtract, multiply, divide"
+                )
+                
+            return MathResult(result, operation, a, b)
+        except Exception as e:
+            if not isinstance(e, InvalidParamsError):
+                raise InvalidParamsError(f"Error performing math operation: {str(e)}")
+            raise
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "a": {
+                    "type": "number",
+                    "description": "First number"
+                },
+                "b": {
+                    "type": "number",
+                    "description": "Second number"
+                },
+                "operation": {
+                    "type": "string",
+                    "enum": ["add", "subtract", "multiply", "divide"],
+                    "description": "Math operation to perform"
+                }
+            },
+            "required": ["a", "b", "operation"],
+            "additionalProperties": False
+        } 

examples/basic_example/commands/time_command.py

@@ -0,0 +1,152 @@
+"""
+Time command module.
+
+This module contains a command for getting current time in different formats and timezones.
+"""
+
+import datetime
+from typing import Dict, Any, Optional
+
+import pytz
+
+from mcp_proxy_adapter import Command, SuccessResult, InvalidParamsError
+
+
+class TimeResult(SuccessResult):
+    """
+    Result of time command.
+    
+    Attributes:
+        time (str): Formatted time string
+        timestamp (int): Unix timestamp
+        timezone (str): Timezone used
+        format (str): Format string used
+    """
+    
+    def __init__(self, time: str, timestamp: int, timezone: str, format: str):
+        """
+        Initialize result.
+        
+        Args:
+            time: Formatted time string
+            timestamp: Unix timestamp
+            timezone: Timezone used
+            format: Format string used
+        """
+        self.time = time
+        self.timestamp = timestamp
+        self.timezone = timezone
+        self.format = format
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dictionary representation
+        """
+        return {
+            "time": self.time,
+            "timestamp": self.timestamp,
+            "timezone": self.timezone,
+            "format": self.format
+        }
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for result.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "time": {"type": "string", "description": "Formatted time string"},
+                "timestamp": {"type": "integer", "description": "Unix timestamp"},
+                "timezone": {"type": "string", "description": "Timezone used"},
+                "format": {"type": "string", "description": "Format string used"}
+            },
+            "required": ["time", "timestamp", "timezone", "format"]
+        }
+
+
+class TimeCommand(Command):
+    """
+    Command that returns current time.
+    
+    This command demonstrates optional parameters and timezone handling.
+    """
+    
+    name = "time"
+    result_class = TimeResult
+    
+    async def execute(
+        self, 
+        format: str = "%Y-%m-%d %H:%M:%S",
+        timezone: str = "UTC"
+    ) -> TimeResult:
+        """
+        Execute command.
+        
+        Args:
+            format: Time format string (strftime format)
+            timezone: Timezone name (e.g., "UTC", "Europe/London")
+            
+        Returns:
+            Time result with formatted time
+            
+        Raises:
+            InvalidParamsError: If timezone is invalid
+        """
+        try:
+            # Validate timezone
+            if timezone not in pytz.all_timezones:
+                raise InvalidParamsError(f"Invalid timezone: {timezone}")
+            
+            # Get current time in the specified timezone
+            tz = pytz.timezone(timezone)
+            now = datetime.datetime.now(tz)
+            
+            # Format time according to the format string
+            formatted_time = now.strftime(format)
+            
+            # Get Unix timestamp
+            timestamp = int(now.timestamp())
+            
+            return TimeResult(
+                time=formatted_time,
+                timestamp=timestamp,
+                timezone=timezone,
+                format=format
+            )
+        except Exception as e:
+            if not isinstance(e, InvalidParamsError):
+                raise InvalidParamsError(f"Error processing time: {str(e)}")
+            raise
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "format": {
+                    "type": "string",
+                    "description": "Time format string (strftime format)",
+                    "default": "%Y-%m-%d %H:%M:%S"
+                },
+                "timezone": {
+                    "type": "string",
+                    "description": "Timezone name (e.g., 'UTC', 'Europe/London')",
+                    "default": "UTC"
+                }
+            },
+            "additionalProperties": False
+        } 

examples/basic_example/config.json

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

examples/basic_example/config.yaml

@@ -0,0 +1,20 @@
+# Configuration for basic MCP Microservice example
+
+# Server settings
+server:
+  host: "localhost"  # Host to bind server
+  port: 8000         # Port to bind server
+
+# Logging settings
+logging:
+  level: "INFO"      # Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+  file: "logs/basic_example.log"  # Log file path
+  rotation:
+    type: "size"     # Log rotation type (size, time)
+    max_bytes: 10485760  # Maximum log file size (10 MB)
+    backup_count: 5  # Number of backup files
+
+# Command discovery settings
+discovery:
+  enabled: true
+  package: "commands"  # Package to discover commands