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

examples/complete_example/commands/system_command.py

@@ -0,0 +1,328 @@
+"""
+System information command module.
+
+This module contains a command that returns detailed information about the system.
+"""
+
+import os
+import sys
+import socket
+import platform
+import datetime
+from typing import Dict, Any, Optional, List
+
+import psutil
+import pytz
+
+from mcp_proxy_adapter import Command, SuccessResult
+
+
+class SystemInfoResult(SuccessResult):
+    """
+    Result of system_info command.
+    
+    Attributes:
+        system (dict): System information
+        cpu (dict): CPU information
+        memory (dict): Memory information
+        disk (dict): Disk information
+        python (dict): Python information
+        network (dict): Network information
+        time (dict): Time information
+    """
+    
+    def __init__(
+        self,
+        system: Dict[str, Any],
+        cpu: Dict[str, Any],
+        memory: Dict[str, Any],
+        disk: Dict[str, Any],
+        python: Dict[str, Any],
+        network: Dict[str, Any],
+        time: Dict[str, Any]
+    ):
+        """
+        Initialize result.
+        
+        Args:
+            system: System information
+            cpu: CPU information
+            memory: Memory information
+            disk: Disk information
+            python: Python information
+            network: Network information
+            time: Time information
+        """
+        self.system = system
+        self.cpu = cpu
+        self.memory = memory
+        self.disk = disk
+        self.python = python
+        self.network = network
+        self.time = time
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dictionary representation
+        """
+        return {
+            "system": self.system,
+            "cpu": self.cpu,
+            "memory": self.memory,
+            "disk": self.disk,
+            "python": self.python,
+            "network": self.network,
+            "time": self.time
+        }
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for result.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "system": {
+                    "type": "object",
+                    "description": "System information",
+                    "properties": {
+                        "platform": {"type": "string"},
+                        "system": {"type": "string"},
+                        "node": {"type": "string"},
+                        "release": {"type": "string"},
+                        "version": {"type": "string"},
+                        "machine": {"type": "string"},
+                        "processor": {"type": "string"},
+                        "uptime": {"type": "number"}
+                    }
+                },
+                "cpu": {
+                    "type": "object",
+                    "description": "CPU information",
+                    "properties": {
+                        "count_physical": {"type": "integer"},
+                        "count_logical": {"type": "integer"},
+                        "usage_percent": {"type": "number"},
+                        "frequency": {"type": "object"}
+                    }
+                },
+                "memory": {
+                    "type": "object",
+                    "description": "Memory information",
+                    "properties": {
+                        "total": {"type": "integer"},
+                        "available": {"type": "integer"},
+                        "used": {"type": "integer"},
+                        "percent": {"type": "number"}
+                    }
+                },
+                "disk": {
+                    "type": "object",
+                    "description": "Disk information",
+                    "properties": {
+                        "partitions": {"type": "array"},
+                        "usage": {"type": "object"}
+                    }
+                },
+                "python": {
+                    "type": "object",
+                    "description": "Python information",
+                    "properties": {
+                        "version": {"type": "string"},
+                        "implementation": {"type": "string"},
+                        "executable": {"type": "string"},
+                        "packages": {"type": "array"}
+                    }
+                },
+                "network": {
+                    "type": "object",
+                    "description": "Network information",
+                    "properties": {
+                        "interfaces": {"type": "array"},
+                        "connections": {"type": "integer"}
+                    }
+                },
+                "time": {
+                    "type": "object",
+                    "description": "Time information",
+                    "properties": {
+                        "current": {"type": "string"},
+                        "utc": {"type": "string"},
+                        "timezone": {"type": "string"},
+                        "timestamp": {"type": "number"}
+                    }
+                }
+            }
+        }
+
+
+class SystemInfoCommand(Command):
+    """
+    Command that returns detailed system information.
+    
+    This command demonstrates gathering and formatting complex system data.
+    """
+    
+    name = "system_info"
+    result_class = SystemInfoResult
+    
+    async def execute(
+        self,
+        include_python_packages: bool = False,
+        include_network_interfaces: bool = True
+    ) -> SystemInfoResult:
+        """
+        Execute command.
+        
+        Args:
+            include_python_packages: Whether to include installed Python packages
+            include_network_interfaces: Whether to include network interfaces
+            
+        Returns:
+            System information result
+        """
+        # Gather system information
+        system_info = {
+            "platform": platform.platform(),
+            "system": platform.system(),
+            "node": platform.node(),
+            "release": platform.release(),
+            "version": platform.version(),
+            "machine": platform.machine(),
+            "processor": platform.processor(),
+            "uptime": psutil.boot_time()
+        }
+        
+        # CPU information
+        cpu_info = {
+            "count_physical": psutil.cpu_count(logical=False),
+            "count_logical": psutil.cpu_count(logical=True),
+            "usage_percent": psutil.cpu_percent(interval=0.1),
+            "frequency": {
+                "current": psutil.cpu_freq().current if psutil.cpu_freq() else 0,
+                "min": psutil.cpu_freq().min if psutil.cpu_freq() and psutil.cpu_freq().min else 0,
+                "max": psutil.cpu_freq().max if psutil.cpu_freq() and psutil.cpu_freq().max else 0
+            }
+        }
+        
+        # Memory information
+        memory = psutil.virtual_memory()
+        memory_info = {
+            "total": memory.total,
+            "available": memory.available,
+            "used": memory.used,
+            "percent": memory.percent
+        }
+        
+        # Disk information
+        disk_info = {
+            "partitions": [],
+            "usage": {}
+        }
+        
+        for partition in psutil.disk_partitions():
+            try:
+                usage = psutil.disk_usage(partition.mountpoint)
+                disk_info["partitions"].append({
+                    "device": partition.device,
+                    "mountpoint": partition.mountpoint,
+                    "fstype": partition.fstype,
+                    "opts": partition.opts
+                })
+                disk_info["usage"][partition.mountpoint] = {
+                    "total": usage.total,
+                    "used": usage.used,
+                    "free": usage.free,
+                    "percent": usage.percent
+                }
+            except (PermissionError, FileNotFoundError):
+                # Some mountpoints may not be accessible
+                pass
+        
+        # Python information
+        python_info = {
+            "version": platform.python_version(),
+            "implementation": platform.python_implementation(),
+            "executable": sys.executable,
+            "packages": []
+        }
+        
+        if include_python_packages:
+            try:
+                import pkg_resources
+                python_info["packages"] = [
+                    {"name": pkg.key, "version": pkg.version}
+                    for pkg in pkg_resources.working_set
+                ]
+            except ImportError:
+                pass
+        
+        # Network information
+        network_info = {
+            "interfaces": [],
+            "connections": len(psutil.net_connections())
+        }
+        
+        if include_network_interfaces:
+            for interface, addresses in psutil.net_if_addrs().items():
+                for address in addresses:
+                    if address.family == socket.AF_INET:  # IPv4
+                        network_info["interfaces"].append({
+                            "interface": interface,
+                            "address": address.address,
+                            "netmask": address.netmask,
+                            "broadcast": address.broadcast
+                        })
+        
+        # Time information
+        now = datetime.datetime.now()
+        utc_now = datetime.datetime.now(pytz.UTC)
+        
+        time_info = {
+            "current": now.isoformat(),
+            "utc": utc_now.isoformat(),
+            "timezone": str(datetime.datetime.now().astimezone().tzinfo),
+            "timestamp": now.timestamp()
+        }
+        
+        return SystemInfoResult(
+            system=system_info,
+            cpu=cpu_info,
+            memory=memory_info,
+            disk=disk_info,
+            python=python_info,
+            network=network_info,
+            time=time_info
+        )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "include_python_packages": {
+                    "type": "boolean",
+                    "description": "Whether to include installed Python packages",
+                    "default": False
+                },
+                "include_network_interfaces": {
+                    "type": "boolean",
+                    "description": "Whether to include network interfaces",
+                    "default": True
+                }
+            },
+            "additionalProperties": False
+        } 

examples/complete_example/config.json

@@ -0,0 +1,41 @@
+{
+  "service": {
+    "name": "Complete Example",
+    "version": "1.0.0",
+    "description": "Полный пример MCP Proxy Adapter"
+  },
+  "server": {
+    "host": "0.0.0.0",
+    "port": 8000,
+    "debug": false,
+    "log_level": "info",
+    "workers": 4
+  },
+  "logging": {
+    "level": "INFO",
+    "file": "logs/complete_example.log",
+    "rotation": {
+      "type": "time",
+      "when": "D",
+      "interval": 1,
+      "backup_count": 30
+    }
+  },
+  "auth": {
+    "enabled": false,
+    "token_expiration": 3600,
+    "secret_key": "change_this_to_a_secure_key_in_production"
+  },
+  "database": {
+    "url": "sqlite:///./data/database.db",
+    "echo": false,
+    "pool_size": 5,
+    "max_overflow": 10
+  },
+  "cache": {
+    "enabled": true,
+    "ttl": 300,
+    "type": "memory",
+    "max_size": 1000
+  }
+} 

examples/complete_example/configs/config.dev.yaml

@@ -0,0 +1,40 @@
+# 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

@@ -0,0 +1,40 @@
+# 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

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

@@ -0,0 +1,20 @@
+# 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

@@ -0,0 +1,139 @@
+"""
+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 typing import Dict, Any
+from pathlib import Path
+
+import mcp_proxy_adapter as mcp
+from mcp_proxy_adapter import MicroService
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.config import config
+
+# 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 Microservice Example")
+    parser.add_argument(
+        "--config", 
+        default="configs/config.dev.yaml",
+        help="Path to configuration file"
+    )
+    return parser.parse_args()
+
+
+def ensure_directories(config_path: str):
+    """
+    Create necessary directories based on configuration.
+    
+    Args:
+        config_path: Path to configuration file
+    """
+    # Extract base directory
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    
+    # Create logs directory
+    os.makedirs(os.path.join(base_dir, "logs"), exist_ok=True)
+    
+    # Create cache directory
+    os.makedirs(os.path.join(base_dir, "cache"), exist_ok=True)
+    
+    # Create data directory
+    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 microservice object
+    """
+    # Parse command line arguments if config_file not provided
+    if config_file is None:
+        args = parse_args()
+        config_file = args.config
+    
+    # Get absolute path to config file
+    current_dir = Path(__file__).parent.absolute()
+    config_path = current_dir / config_file
+    
+    # Fall back to config.json if specified file doesn't exist
+    if not config_path.exists():
+        config_path = current_dir / "config.json"
+    
+    # Create necessary directories
+    ensure_directories(str(config_path))
+    
+    # Load configuration if exists
+    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")
+    
+    # Create microservice
+    service = MicroService(
+        title="Complete MCP Microservice Example",
+        description="Full-featured microservice with Docker support",
+        version="1.0.0",
+        config_path=str(config_path) if config_path.exists() else None
+    )
+    
+    # Safely register commands from package
+    try:
+        # Clear any existing registrations to prevent conflicts
+        package_path = "commands"
+        
+        # Get currently registered commands
+        commands = registry.get_all_commands()
+        for cmd_name in list(commands.keys()):
+            try:
+                registry.unregister(cmd_name)
+            except Exception as e:
+                logger.debug(f"Error unregistering command {cmd_name}: {e}")
+        
+        # Discover and register commands
+        service.discover_commands(package_path)
+        logger.info(f"Discovered and registered commands from package: {package_path}")
+    except Exception as e:
+        logger.error(f"Error discovering commands: {e}")
+    
+    return service
+
+
+def main():
+    """Run microservice with command discovery."""
+    # Setup application
+    service = setup_application()
+    
+    # Check if port is overridden by environment variable (for testing)
+    if "TEST_SERVER_PORT" in os.environ:
+        port = int(os.environ["TEST_SERVER_PORT"])
+        service.port = port
+        logger.info(f"Using test port from environment: {port}")
+    
+    # Run server with parameters from configuration
+    service.run()
+
+
+if __name__ == "__main__":
+    main()