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

examples/commands/get_date_command.py

@@ -1,98 +0,0 @@
-"""
-Module for the get_date command implementation.
-"""
-
-from datetime import datetime
-from typing import Any, Dict
-
-from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import CommandResult
-from mcp_proxy_adapter.commands.command_registry import registry
-from mcp_proxy_adapter.core.logging import logger
-
-
-class GetDateResult(CommandResult):
-    """Result of getting current date"""
-    
-    def __init__(self, date: str):
-        """
-        Initialize the GetDateResult.
-        
-        Args:
-            date: Date in ISO 8601 format
-        """
-        self.date = date
-        
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert the result to a dictionary.
-        
-        Returns:
-            Dictionary with the date
-        """
-        return {"date": self.date}
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get the JSON schema for this result.
-        
-        Returns:
-            JSON schema
-        """
-        return {
-            "type": "object",
-            "required": ["date"],
-            "properties": {
-                "date": {
-                    "type": "string",
-                    "description": "Current date and time in ISO 8601 format",
-                    "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}[+-]\\d{2}:?\\d{2}$"
-                }
-            }
-        }
-
-
-class GetDateCommand(Command):
-    """
-    Command that returns the current date and time in ISO 8601 format.
-    """
-    
-    name = "get_date"
-    
-    async def execute(self) -> GetDateResult:
-        """
-        Execute the get_date command.
-        
-        Returns:
-            GetDateResult: Result with date in ISO 8601 format
-        """
-        # Get current time with timezone info
-        now = datetime.now().astimezone()
-        
-        # Format to ISO 8601
-        date_str = now.strftime("%Y-%m-%dT%H:%M:%S%z")
-        
-        # Insert colon in timezone offset (e.g. +0300 -> +03:00)
-        if len(date_str) >= 6:
-            date_str = date_str[:-2] + ":" + date_str[-2:]
-            
-        logger.debug(f"Generated date: {date_str}")
-        return GetDateResult(date=date_str)
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get the JSON schema for this command.
-        
-        Returns:
-            JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {}
-        }
-
-
-# Register the command
-registry.register(GetDateCommand) 

examples/commands/new_uuid4_command.py

@@ -1,91 +0,0 @@
-"""
-Module for the new_uuid4 command implementation.
-"""
-
-import uuid
-from typing import Any, Dict
-
-from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import CommandResult
-from mcp_proxy_adapter.commands.command_registry import registry
-from mcp_proxy_adapter.core.logging import logger
-
-
-class NewUuid4Result(CommandResult):
-    """Result of UUID4 generation"""
-    
-    def __init__(self, uuid_str: str):
-        """
-        Initialize the NewUuid4Result.
-        
-        Args:
-            uuid_str: UUID in string format
-        """
-        self.uuid = uuid_str
-        
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert the result to a dictionary.
-        
-        Returns:
-            Dictionary with the UUID
-        """
-        return {"uuid": self.uuid}
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get the JSON schema for this result.
-        
-        Returns:
-            JSON schema
-        """
-        return {
-            "type": "object",
-            "required": ["uuid"],
-            "properties": {
-                "uuid": {
-                    "type": "string",
-                    "description": "Generated UUID4 in string format",
-                    "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
-                }
-            }
-        }
-
-
-class NewUuid4Command(Command):
-    """
-    Command that generates a new UUID version 4 (random).
-    """
-    
-    name = "new_uuid4"
-    
-    async def execute(self) -> NewUuid4Result:
-        """
-        Execute the new_uuid4 command.
-        
-        Returns:
-            NewUuid4Result: Result with UUID in string format
-        """
-        # Generate a UUID4
-        uuid_str = str(uuid.uuid4())
-        
-        logger.debug(f"Generated UUID4: {uuid_str}")
-        return NewUuid4Result(uuid_str=uuid_str)
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get the JSON schema for this command.
-        
-        Returns:
-            JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {}
-        }
-
-
-# Register the command
-registry.register(NewUuid4Command) 

examples/complete_example/Dockerfile

@@ -1,24 +0,0 @@
-FROM python:3.11-slim
-
-# Set working directory
-WORKDIR /app
-
-# Install dependencies
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Create necessary directories
-RUN mkdir -p /app/logs /app/cache /app/data
-
-# Copy application files
-COPY . .
-
-# Set environment variables
-ENV PYTHONUNBUFFERED=1
-ENV CONFIG_PATH=/app/configs/config.docker.yaml
-
-# Expose API port
-EXPOSE 8000
-
-# Run the application
-CMD ["python", "server.py", "--config", "/app/configs/config.docker.yaml"] 

examples/complete_example/README.md

@@ -1,92 +0,0 @@
-# Complete MCP Proxy Adapter Example
-
-This example demonstrates a complete MCP Proxy Adapter application with Docker support,
-environment-specific configuration, and multiple commands.
-
-## Structure
-
-```
-complete_example/
-├── cache/                     # Cache directory
-├── commands/                  # Commands directory
-│   ├── __init__.py           # Package initialization
-│   ├── db_command.py         # Database command
-│   ├── file_command.py       # File operations command
-│   └── system_command.py     # System information command
-├── configs/                   # Configuration files
-│   ├── config.dev.yaml       # Development config
-│   └── config.docker.yaml    # Docker config
-├── docker-compose.yml        # Docker Compose file
-├── Dockerfile                # Docker image definition
-├── logs/                     # Logs directory
-├── README.md                 # This documentation file
-├── requirements.txt          # Python dependencies
-└── server.py                 # Server startup file
-```
-
-## Features
-
-- Multiple commands in separate files
-- Environment-specific configuration
-- Docker support
-- Volume mounting for logs, cache, and config
-- Network configuration
-
-## Running Locally
-
-```bash
-# Navigate to the project directory
-cd examples/complete_example
-
-# Create virtual environment (optional)
-python -m venv venv
-source venv/bin/activate  # Linux/Mac
-# or
-# venv\Scripts\activate  # Windows
-
-# Install dependencies
-pip install -r requirements.txt
-pip install -e ../..  # Install mcp_proxy_adapter from parent directory
-
-# Run the server with development config
-python server.py --config configs/config.dev.yaml
-```
-
-The server will be available at [http://localhost:8000](http://localhost:8000).
-
-## Running with Docker
-
-```bash
-# Navigate to the project directory
-cd examples/complete_example
-
-# Build the Docker image
-docker build -t mcp-proxy-adapter-example .
-
-# Run with Docker Compose
-docker-compose up
-```
-
-The server will be available at [http://localhost:8000](http://localhost:8000).
-
-## Available Commands
-
-The microservice includes several commands that demonstrate different features:
-
-1. `system_info` - Returns system information
-2. `file_operations` - Performs file operations
-3. `db_query` - Executes database queries
-
-For details on each command, see the API documentation at [http://localhost:8000/docs](http://localhost:8000/docs)
-when the server is running.
-
-## Docker Configuration
-
-The Docker setup includes:
-
-- Volume mounts for logs, cache, and configuration
-- Network configuration for integration with other services
-- User mapping to avoid permission issues
-- Port forwarding
-
-For details, see the `docker-compose.yml` file. 

examples/complete_example/__init__.py

@@ -1,8 +0,0 @@
-"""
-Complete example for MCP Microservice.
-
-This package contains a complete example of using MCP Microservice framework
-with Docker support, multiple commands, configuration management, and tests.
-"""
-
-__all__ = [] 

examples/complete_example/commands/__init__.py

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

examples/complete_example/commands/system_command.py

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

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