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

examples/complete_example/configs/config.dev.yaml

@@ -1,40 +0,0 @@
-# Development configuration for complete MCP Microservice example
-
-# Server settings
-server:
-  host: "localhost"  # Host to bind server
-  port: 8000         # Port to bind server
-  workers: 1         # Number of worker processes
-  debug: true        # Enable debug mode
-
-# Logging settings
-logging:
-  level: "DEBUG"     # Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
-  file: "logs/complete_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
-
-# Cache settings
-cache:
-  enabled: true
-  type: "file"       # Cache type (file, memory, redis)
-  path: "cache"      # Cache directory
-  ttl: 300           # Default TTL in seconds
-
-# Database settings (for db_command)
-database:
-  enabled: false     # Database is disabled in development
-  type: "sqlite"     # Database type
-  path: ":memory:"   # Database path (in-memory SQLite)
-
-# File operations settings (for file_command)
-files:
-  base_path: "."     # Base path for file operations
-  allowed_extensions: [".txt", ".log", ".json", ".yaml"]  # Allowed file extensions 

examples/complete_example/configs/config.docker.yaml

@@ -1,40 +0,0 @@
-# Docker configuration for complete MCP Microservice example
-
-# Server settings
-server:
-  host: "0.0.0.0"    # Bind to all interfaces in Docker
-  port: 8000         # Port to bind server
-  workers: 2         # Number of worker processes
-  debug: false       # Disable debug mode in production
-
-# Logging settings
-logging:
-  level: "INFO"      # Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
-  file: "/app/logs/complete_example.log"  # Log file path in Docker container
-  rotation:
-    type: "size"     # Log rotation type (size, time)
-    max_bytes: 10485760  # Maximum log file size (10 MB)
-    backup_count: 10  # Number of backup files
-
-# Command discovery settings
-discovery:
-  enabled: true
-  package: "commands"  # Package to discover commands
-
-# Cache settings
-cache:
-  enabled: true
-  type: "file"       # Cache type (file, memory, redis)
-  path: "/app/cache"  # Cache directory in Docker container
-  ttl: 3600          # Default TTL in seconds (1 hour)
-
-# Database settings (for db_command)
-database:
-  enabled: true      # Enable database in Docker environment
-  type: "sqlite"     # Database type
-  path: "/app/data/db.sqlite"  # Database path in Docker container
-
-# File operations settings (for file_command)
-files:
-  base_path: "/app/data"  # Base path for file operations in Docker
-  allowed_extensions: [".txt", ".log", ".json", ".yaml"]  # Allowed file extensions 

examples/complete_example/docker-compose.yml

@@ -1,35 +0,0 @@
-version: '3.8'
-
-services:
-  mcp-proxy-adapter:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    image: mcp-proxy-adapter-example:latest
-    container_name: mcp-proxy-adapter-example
-    restart: unless-stopped
-    ports:
-      - "8000:8000"
-    volumes:
-      # Mount configuration, logs, and cache from host
-      - ./configs:/app/configs:ro
-      - ./logs:/app/logs
-      - ./cache:/app/cache
-      - ./data:/app/data
-    environment:
-      - PYTHONUNBUFFERED=1
-      - CONFIG_PATH=/app/configs/config.docker.yaml
-    networks:
-      - smart-assistant
-    user: "${UID:-1000}:${GID:-1000}"  # Use host user ID to avoid permission issues
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 10s
-
-networks:
-  smart-assistant:
-    # Use external network if it exists, otherwise create it
-    external: true 

examples/complete_example/requirements.txt

@@ -1,20 +0,0 @@
-# Python dependencies for MCP Microservice complete example
-
-# Core dependencies
-fastapi>=0.95.0,<1.0.0
-pydantic>=2.0.0,<3.0.0
-uvicorn>=0.22.0,<1.0.0
-docstring-parser>=0.15,<1.0.0
-typing-extensions>=4.5.0,<5.0.0
-jsonrpc>=1.2.0,<2.0.0
-
-# For system_command
-psutil>=5.9.0,<6.0.0
-pytz>=2023.3
-
-# For file_command
-aiofiles>=23.1.0,<24.0.0
-
-# For db_command
-aiosqlite>=0.17.0,<1.0.0
-SQLAlchemy>=2.0.0,<3.0.0 

examples/complete_example/server.py

@@ -1,113 +0,0 @@
-"""
-Complete MCP Microservice example.
-
-This example demonstrates a complete microservice application with Docker support,
-environment-specific configuration, and multiple commands.
-"""
-
-import os
-import sys
-import argparse
-from pathlib import Path
-import uvicorn
-from mcp_proxy_adapter.api.app import create_app
-from mcp_proxy_adapter.commands.command_registry import registry
-from mcp_proxy_adapter.config import config
-from mcp_proxy_adapter.core.logging import logger, setup_logging
-
-# Add commands directory to path for local imports
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-
-def parse_args():
-    """
-    Parse command line arguments.
-    
-    Returns:
-        Parsed arguments
-    """
-    parser = argparse.ArgumentParser(description="MCP Complete Example")
-    parser.add_argument(
-        "--config",
-        default="configs/config.dev.yaml",
-        help="Path to configuration file"
-    )
-    return parser.parse_args()
-
-
-def ensure_directories():
-    """
-    Create necessary directories based on configuration.
-    """
-    base_dir = os.path.dirname(os.path.abspath(__file__))
-    os.makedirs(os.path.join(base_dir, "logs"), exist_ok=True)
-    os.makedirs(os.path.join(base_dir, "cache"), exist_ok=True)
-    os.makedirs(os.path.join(base_dir, "data"), exist_ok=True)
-
-
-def setup_application(config_file=None):
-    """
-    Setup and configure the microservice application.
-    
-    Args:
-        config_file: Path to configuration file (optional)
-        
-    Returns:
-        Configured FastAPI application
-    """
-    if config_file is None:
-        args = parse_args()
-        config_file = args.config
-    current_dir = Path(__file__).parent.absolute()
-    config_path = current_dir / config_file
-    if not config_path.exists():
-        config_path = current_dir / "config.json"
-    ensure_directories()
-    if config_path.exists():
-        config.load_from_file(str(config_path))
-        logger.info(f"Loaded configuration from {config_path}")
-    else:
-        logger.warning(f"Configuration file {config_path} not found, using defaults")
-    app = create_app()
-    app.title = "Complete MCP Microservice Example"
-    app.description = "Full-featured microservice with Docker support"
-    app.version = "1.0.0"
-    # Discover and register commands from the commands directory
-    package_path = "commands"
-    try:
-        registered_commands = registry.get_all_commands()
-        for cmd_name in list(registered_commands.keys()):
-            try:
-                registry.unregister(cmd_name)
-            except Exception as e:
-                logger.debug(f"Error unregistering command {cmd_name}: {e}")
-        registry.discover_commands(package_path)
-        logger.info(f"Discovered commands from package: {package_path}")
-    except Exception as e:
-        logger.error(f"Error discovering commands: {e}")
-    return app
-
-
-def main():
-    """Run microservice with command discovery."""
-    log_level = config.get("logging.level", "INFO")
-    setup_logging(log_level)
-    app = setup_application()
-    host = config.get("server.host", "0.0.0.0")
-    port = config.get("server.port", 8000)
-    if "TEST_SERVER_PORT" in os.environ:
-        port = int(os.environ["TEST_SERVER_PORT"])
-        logger.info(f"Using test port from environment: {port}")
-    logger.info(f"Starting server on {host}:{port}")
-    debug = config.get("server.debug", False)
-    uvicorn.run(
-        app,
-        host=host,
-        port=port,
-        reload=debug,
-        log_level=log_level.lower()
-    )
-
-
-if __name__ == "__main__":
-    main() 

examples/di_example/.pytest_cache/README.md

@@ -1,8 +0,0 @@
-# pytest cache directory #
-
-This directory contains data from the pytest's cache plugin,
-which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
-
-**Do not** commit this to version control.
-
-See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

examples/di_example/server.py

@@ -1,249 +0,0 @@
-"""
-Example of using dependency injection in a microservice.
-
-This example demonstrates how to:
-1. Create service dependencies
-2. Configure a dependency container
-3. Register commands with dependencies
-4. Run a microservice with dependency injection
-"""
-
-import asyncio
-import logging
-import os
-from typing import Dict, List, Any
-
-import uvicorn
-from fastapi import FastAPI
-
-from mcp_proxy_adapter import create_app
-from mcp_proxy_adapter.commands import registry, container
-from examples.commands.echo_command_di import EchoCommand, TimeService
-
-
-class DatabaseService:
-    """
-    Mock database service as an example dependency.
-    """
-    
-    def __init__(self, connection_string: str):
-        """
-        Initialize database service.
-        
-        Args:
-            connection_string: Database connection string
-        """
-        self.connection_string = connection_string
-        self.is_connected = False
-        self.data = {}
-        
-    async def connect(self):
-        """Connect to the database."""
-        # Simulate connection delay
-        await asyncio.sleep(0.1)
-        self.is_connected = True
-        print(f"Connected to database: {self.connection_string}")
-        
-    async def disconnect(self):
-        """Disconnect from the database."""
-        if self.is_connected:
-            # Simulate disconnection delay
-            await asyncio.sleep(0.1)
-            self.is_connected = False
-            print("Disconnected from database")
-    
-    def get_item(self, key: str) -> Any:
-        """Get item from the database."""
-        if not self.is_connected:
-            raise RuntimeError("Not connected to database")
-        return self.data.get(key)
-    
-    def set_item(self, key: str, value: Any):
-        """Set item in the database."""
-        if not self.is_connected:
-            raise RuntimeError("Not connected to database")
-        self.data[key] = value
-
-
-class ConfigService:
-    """
-    Configuration service as an example dependency.
-    """
-    
-    def __init__(self, config_path: str = None):
-        """
-        Initialize configuration service.
-        
-        Args:
-            config_path: Path to config file (optional)
-        """
-        self.config_path = config_path
-        self.config = {
-            "app_name": "DI Example",
-            "version": "1.0.0",
-            "debug": True
-        }
-        
-    def get(self, key: str, default: Any = None) -> Any:
-        """Get configuration value."""
-        return self.config.get(key, default)
-        
-    def set(self, key: str, value: Any):
-        """Set configuration value."""
-        self.config[key] = value
-
-
-class DataCommand(EchoCommand):
-    """
-    Command that uses multiple dependencies.
-    
-    This command demonstrates using multiple injected dependencies.
-    """
-    
-    name = "data"
-    
-    def __init__(self, time_service: TimeService, db_service: DatabaseService, config: ConfigService):
-        """
-        Initialize command with multiple dependencies.
-        
-        Args:
-            time_service: Service for time operations
-            db_service: Service for database operations
-            config: Service for configuration
-        """
-        super().__init__(time_service)
-        self.db_service = db_service
-        self.config = config
-        
-    async def execute(self, action: str = "get", key: str = "data", value: str = None) -> Any:
-        """
-        Execute data command.
-        
-        Args:
-            action: Operation to perform (get or set)
-            key: Data key
-            value: Data value (for set operation)
-            
-        Returns:
-            Command result
-        """
-        timestamp = self.time_service.get_current_time()
-        
-        if action == "get":
-            result = self.db_service.get_item(key)
-            return EchoCommand.result_class(
-                message=f"Got {key}: {result}",
-                timestamp=timestamp,
-                data=result
-            )
-        elif action == "set" and value is not None:
-            self.db_service.set_item(key, value)
-            return EchoCommand.result_class(
-                message=f"Set {key} to {value}",
-                timestamp=timestamp,
-                data={key: value}
-            )
-        else:
-            return EchoCommand.result_class(
-                message=f"Invalid action: {action}",
-                timestamp=timestamp,
-                error="invalid_action"
-            )
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Returns JSON schema for command parameters."""
-        return {
-            "type": "object",
-            "properties": {
-                "action": {
-                    "type": "string",
-                    "enum": ["get", "set"],
-                    "description": "Action to perform on data"
-                },
-                "key": {
-                    "type": "string",
-                    "description": "Data key"
-                },
-                "value": {
-                    "type": ["string", "null"],
-                    "description": "Data value (for set action)"
-                }
-            },
-            "required": ["action", "key"]
-        }
-
-
-async def setup_services():
-    """Set up and register all services in the container."""
-    # Create services
-    time_service = TimeService()
-    db_service = DatabaseService("sqlite://:memory:")
-    config_service = ConfigService()
-    
-    # Connect to database
-    await db_service.connect()
-    
-    # Register in container
-    container.register("time_service", time_service)
-    container.register("db_service", db_service)
-    container.register("config", config_service)
-    
-    return {
-        "time_service": time_service,
-        "db_service": db_service,
-        "config": config_service
-    }
-
-
-def register_commands(services):
-    """Register commands with dependencies."""
-    # Create command instances with dependencies
-    echo_command = EchoCommand(services["time_service"])
-    data_command = DataCommand(
-        services["time_service"],
-        services["db_service"],
-        services["config"]
-    )
-    
-    # Register commands
-    registry.register(echo_command)
-    registry.register(data_command)
-
-
-async def main():
-    """Run the example server with dependency injection."""
-    # Configure logging
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-    )
-    
-    # Setup services
-    services = await setup_services()
-    
-    # Register commands with their dependencies
-    register_commands(services)
-    
-    # Create FastAPI app with MCP adapter
-    app = create_app()
-    
-    # Add startup and shutdown events
-    @app.on_event("shutdown")
-    async def shutdown_event():
-        # Disconnect database on shutdown
-        await services["db_service"].disconnect()
-    
-    # Run the server
-    config = uvicorn.Config(
-        app=app,
-        host="0.0.0.0",
-        port=8000,
-        log_level="info"
-    )
-    server = uvicorn.Server(config)
-    await server.serve()
-
-
-if __name__ == "__main__":
-    asyncio.run(main()) 

examples/fix_vstl_help.py

@@ -1,123 +0,0 @@
-#!/usr/bin/env python3
-"""
-Скрипт для исправления проблемы с обработкой JavaScript null в сервисе VSTL.
-
-Этот скрипт демонстрирует проблему с обработкой null значений в VSTL 
-и способ её решения с помощью обновленной реализации метода validate_params.
-"""
-
-import sys
-import json
-import requests
-from typing import Dict, Any, Optional
-
-# URL и заголовки для VSTL сервиса
-VSTL_URL = "http://localhost:8000/cmd"
-HEADERS = {"Content-Type": "application/json"}
-
-def call_vstl_help(params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-    """
-    Вызывает команду help в сервисе VSTL.
-    
-    Args:
-        params: Параметры для команды help
-        
-    Returns:
-        Dict[str, Any]: Ответ от сервиса
-    """
-    payload = {
-        "jsonrpc": "2.0",
-        "method": "help",
-        "params": params or {},
-        "id": 1
-    }
-    
-    response = requests.post(VSTL_URL, json=payload, headers=HEADERS)
-    return response.json()
-
-def test_validate_params_fix():
-    """
-    Демонстрирует проблему с обработкой null и решение с помощью
-    улучшенной реализации метода validate_params.
-    """
-    # Оригинальная реализация метода validate_params
-    def original_validate_params(params: Dict[str, Any]) -> Dict[str, Any]:
-        if params is None:
-            params = {}
-            
-        validated_params = params.copy()
-        
-        for key, value in list(validated_params.items()):
-            if value is None or (isinstance(value, str) and value == ""):
-                if key in ["cmdname"]:
-                    pass
-                else:
-                    del validated_params[key]
-                
-        return validated_params
-
-    # Улучшенная реализация метода validate_params
-    def improved_validate_params(params: Dict[str, Any]) -> Dict[str, Any]:
-        if params is None:
-            params = {}
-            
-        validated_params = params.copy()
-        
-        for key, value in list(validated_params.items()):
-            if value is None or (isinstance(value, str) and value.lower() in ["null", "none", ""]):
-                if key in ["cmdname"]:
-                    validated_params[key] = None
-                else:
-                    del validated_params[key]
-                
-        return validated_params
-
-    # Тестирование оригинальной реализации
-    original_params = {"unknown_param": "null"}
-    
-    print("\n=== Оригинальные параметры ===")
-    print(f"Параметры: {original_params}")
-    print("Результат validate_params (оригинальный):")
-    try:
-        print(original_validate_params(original_params))
-    except Exception as e:
-        print(f"ОШИБКА: {e}")
-        
-    # Тестирование улучшенной реализации
-    print("\n=== Улучшенная обработка 'null' ===")
-    print(f"Параметры: {original_params}")
-    print("Результат validate_params (улучшенный):")
-    try:
-        print(improved_validate_params(original_params))
-    except Exception as e:
-        print(f"ОШИБКА: {e}")
-        
-    # Проверка запроса к VSTL с null в параметрах
-    print("\n=== Тестирование запроса к VSTL ===")
-    
-    # Тест с null в параметрах
-    print("\nТест 1: Запрос с null в параметрах")
-    response = call_vstl_help({"unknown_param": None})
-    print(f"Ответ: {json.dumps(response, indent=2)}")
-    
-    # Тест с строковым "null" в параметрах
-    print("\nТест 2: Запрос со строковым 'null' в параметрах")
-    response = call_vstl_help({"unknown_param": "null"})
-    print(f"Ответ: {json.dumps(response, indent=2)}")
-    
-    # Рекомендации по исправлению
-    print("\n=== Рекомендации по исправлению ===")
-    print("""
-1. Обновите метод validate_params в файле commands/base.py на улучшенную версию:
-   - Добавьте проверку на строки "null" и "none" (в любом регистре)
-   - Для параметров, которые могут быть None, преобразуйте их в Python None
-   
-2. Обновите метод execute команды help, чтобы игнорировать неизвестные параметры:
-   - Добавьте аргумент **kwargs в сигнатуру метода
-
-Эти изменения улучшат совместимость с клиентами, отправляющими JavaScript null
-и сделают API более устойчивым к различным форматам входных данных.
-    """)
-
-if __name__ == "__main__":
-    test_validate_params_fix()