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

examples/basic_example/README.md

@@ -1,245 +0,0 @@
-# Basic MCP Proxy Adapter Example
-
-This example demonstrates how to use MCP Proxy Adapter to create a microservice with multiple commands organized in separate files.
-
-## English Documentation
-
-### Overview
-
-This example shows:
-- Creating a microservice using MCP Proxy Adapter
-- Configuring the service using JSON configuration file
-- Automatic command discovery from a package
-- Implementing various command types with their result classes
-- Running the service with auto-reload for development
-
-### Setup
-
-1. Make sure you have installed MCP Proxy Adapter package
-2. Install additional dependencies:
-   ```
-   pip install pytz uvicorn
-   ```
-
-### Configuration
-
-The service uses `config.json` for configuration. The key settings are:
-- Server host and port
-- Logging configuration
-- Command discovery settings
-
-### Available Commands
-
-The example includes several commands:
-- `echo` - Echo back a message
-- `time` - Get current time in different formats and timezones
-- `math` - Perform basic math operations
-
-### Running the Example
-
-```bash
-cd examples/basic_example
-python server.py
-```
-
-The service will start on http://localhost:8000 by default, with API documentation available at http://localhost:8000/docs
-
-### Testing Commands
-
-You can test commands using curl:
-
-```bash
-# Echo command
-curl -X POST http://localhost:8000/cmd -H "Content-Type: application/json" -d '{"command": "echo", "params": {"message": "Hello, world!"}}'
-
-# Time command
-curl -X POST http://localhost:8000/cmd -H "Content-Type: application/json" -d '{"command": "time", "params": {"timezone": "Europe/London"}}'
-
-# JSON-RPC style request
-curl -X POST http://localhost:8000/api/jsonrpc -H "Content-Type: application/json" -d '{"jsonrpc": "2.0", "method": "echo", "params": {"message": "Hello RPC!"}, "id": 1}'
-```
-
-## Русская документация
-
-### Обзор
-
-Этот пример демонстрирует:
-- Создание микросервиса с использованием MCP Proxy Adapter
-- Настройку сервиса с использованием JSON-файла конфигурации
-- Автоматическое обнаружение команд из пакета
-- Реализацию различных типов команд с их классами результатов
-- Запуск сервиса с автоперезагрузкой для разработки
-
-### Настройка
-
-1. Убедитесь, что у вас установлен пакет MCP Proxy Adapter
-2. Установите дополнительные зависимости:
-   ```
-   pip install pytz uvicorn
-   ```
-
-### Конфигурация
-
-Сервис использует `config.json` для конфигурации. Основные настройки:
-- Хост и порт сервера
-- Настройки логирования
-- Настройки обнаружения команд
-
-### Доступные команды
-
-Пример включает несколько команд:
-- `echo` - Эхо-ответ сообщения
-- `time` - Получение текущего времени в разных форматах и часовых поясах
-- `math` - Выполнение базовых математических операций
-
-### Запуск примера
-
-```bash
-cd examples/basic_example
-python server.py
-```
-
-Сервис запустится на http://localhost:8000 по умолчанию, документация API доступна по адресу http://localhost:8000/docs
-
-### Тестирование команд
-
-Вы можете тестировать команды с помощью curl:
-
-```bash
-# Команда echo
-curl -X POST http://localhost:8000/cmd -H "Content-Type: application/json" -d '{"command": "echo", "params": {"message": "Привет, мир!"}}'
-
-# Команда time
-curl -X POST http://localhost:8000/cmd -H "Content-Type: application/json" -d '{"command": "time", "params": {"timezone": "Europe/Moscow"}}'
-
-# Запрос в стиле JSON-RPC
-curl -X POST http://localhost:8000/api/jsonrpc -H "Content-Type: application/json" -d '{"jsonrpc": "2.0", "method": "echo", "params": {"message": "Привет RPC!"}, "id": 1}'
-```
-
-## Структура примера
-
-```
-basic_example/
-├── commands/                   # Директория с командами
-│   ├── __init__.py            # Инициализация пакета команд
-│   ├── echo_command.py        # Команда эхо
-│   ├── math_command.py        # Математическая команда
-│   └── time_command.py        # Команда времени
-├── config.json                # Файл конфигурации JSON
-├── 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. Прямое использование FastAPI и uvicorn с MCP Proxy Adapter
-2. Организация команд в отдельные файлы
-3. Автоматическое обнаружение и регистрация команд
-4. Различные типы команд и параметров
-5. Обработка ошибок
-6. Различные способы вызова команд (JSON-RPC, /cmd, /api/command/{command_name}) 

examples/basic_example/__init__.py

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

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

examples/basic_example/commands/echo_command.py

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

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

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