mcp-proxy-adapter 4.1.1__py3-none-any.whl → 6.1.0__py3-none-any.whl

mcp_proxy_adapter/api/middleware/rate_limit.py

@@ -1,152 +0,0 @@
-"""
-Middleware for rate limiting.
-"""
-
-import time
-from typing import Dict, List, Callable, Awaitable
-from collections import defaultdict
-
-from fastapi import Request, Response
-from starlette.responses import JSONResponse
-
-from mcp_proxy_adapter.core.logging import logger
-from .base import BaseMiddleware
-
-class RateLimitMiddleware(BaseMiddleware):
-    """
-    Middleware for limiting request rate.
-    """
-    
-    def __init__(self, app, rate_limit: int = 100, time_window: int = 60, 
-                 by_ip: bool = True, by_user: bool = True,
-                 public_paths: List[str] = None):
-        """
-        Initializes middleware for rate limiting.
-        
-        Args:
-            app: FastAPI application
-            rate_limit: Maximum number of requests in the specified time period
-            time_window: Time period in seconds
-            by_ip: Limit requests by IP address
-            by_user: Limit requests by user
-            public_paths: List of paths for which rate limiting is not applied
-        """
-        super().__init__(app)
-        self.rate_limit = rate_limit
-        self.time_window = time_window
-        self.by_ip = by_ip
-        self.by_user = by_user
-        self.public_paths = public_paths or [
-            "/docs", 
-            "/redoc", 
-            "/openapi.json", 
-            "/health"
-        ]
-        
-        # Storage for requests by IP
-        self.ip_requests = defaultdict(list)
-        
-        # Storage for requests by user
-        self.user_requests = defaultdict(list)
-    
-    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
-        """
-        Processes request and checks rate limit.
-        
-        Args:
-            request: Request.
-            call_next: Next handler.
-            
-        Returns:
-            Response.
-        """
-        # Check if path is public
-        path = request.url.path
-        if self._is_public_path(path):
-            # If path is public, skip rate limiting
-            return await call_next(request)
-        
-        # Current time
-        current_time = time.time()
-        
-        # Get client IP address
-        client_ip = request.client.host if request.client else "unknown"
-        
-        # Get user from request state (if any)
-        username = getattr(request.state, "username", None)
-        
-        # Check limit by IP
-        if self.by_ip and client_ip != "unknown":
-            # Clean old requests
-            self._clean_old_requests(self.ip_requests[client_ip], current_time)
-            
-            # Check number of requests
-            if len(self.ip_requests[client_ip]) >= self.rate_limit:
-                logger.warning(f"Rate limit exceeded for IP: {client_ip} | Path: {path}")
-                return self._create_error_response("Rate limit exceeded", 429)
-            
-            # Add current request
-            self.ip_requests[client_ip].append(current_time)
-        
-        # Check limit by user
-        if self.by_user and username:
-            # Clean old requests
-            self._clean_old_requests(self.user_requests[username], current_time)
-            
-            # Check number of requests
-            if len(self.user_requests[username]) >= self.rate_limit:
-                logger.warning(f"Rate limit exceeded for user: {username} | Path: {path}")
-                return self._create_error_response("Rate limit exceeded", 429)
-            
-            # Add current request
-            self.user_requests[username].append(current_time)
-        
-        # Call the next middleware or main handler
-        return await call_next(request)
-    
-    def _clean_old_requests(self, requests: List[float], current_time: float) -> None:
-        """
-        Cleans old requests that are outside the time window.
-        
-        Args:
-            requests: List of request timestamps.
-            current_time: Current time.
-        """
-        min_time = current_time - self.time_window
-        while requests and requests[0] < min_time:
-            requests.pop(0)
-    
-    def _is_public_path(self, path: str) -> bool:
-        """
-        Checks if the path is public.
-        
-        Args:
-            path: Path to check.
-            
-        Returns:
-            True if path is public, False otherwise.
-        """
-        return any(path.startswith(public_path) for public_path in self.public_paths)
-    
-    def _create_error_response(self, message: str, status_code: int) -> Response:
-        """
-        Creates error response in JSON-RPC format.
-        
-        Args:
-            message: Error message.
-            status_code: HTTP status code.
-            
-        Returns:
-            JSON response with error.
-        """
-        return JSONResponse(
-            status_code=status_code,
-            content={
-                "jsonrpc": "2.0",
-                "error": {
-                    "code": -32000,
-                    "message": message
-                },
-                "id": None
-            }
-        ) 

mcp_proxy_adapter/commands/reload_settings_command.py

@@ -1,125 +0,0 @@
-"""
-Reload Settings Command
-
-This command allows reloading configuration settings from files and environment variables.
-"""
-
-from typing import Dict, Any
-from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.core.settings import reload_settings, get_custom_settings
-from mcp_proxy_adapter.core.logging import get_logger
-
-
-class ReloadSettingsResult:
-    """
-    Result class for reload settings command.
-    """
-    
-    def __init__(
-        self,
-        success: bool,
-        message: str,
-        custom_settings: Dict[str, Any] = None,
-        error_message: str = None
-    ):
-        self.success = success
-        self.message = message
-        self.custom_settings = custom_settings or {}
-        self.error_message = error_message
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert result to dictionary."""
-        result = {
-            "success": self.success,
-            "message": self.message,
-            "custom_settings": self.custom_settings
-        }
-        if self.error_message:
-            result["error_message"] = self.error_message
-        return result
-    
-    def get_schema(self) -> Dict[str, Any]:
-        """Get JSON schema for the result."""
-        return {
-            "type": "object",
-            "properties": {
-                "success": {
-                    "type": "boolean",
-                    "description": "Whether the operation was successful"
-                },
-                "message": {
-                    "type": "string",
-                    "description": "Operation result message"
-                },
-                "custom_settings": {
-                    "type": "object",
-                    "description": "Current custom settings after reload",
-                    "additionalProperties": True
-                },
-                "error_message": {
-                    "type": "string",
-                    "description": "Error message if operation failed"
-                }
-            },
-            "required": ["success", "message", "custom_settings"]
-        }
-
-
-class ReloadSettingsCommand(Command):
-    """
-    Command to reload configuration settings.
-    """
-    
-    name = "reload_settings"
-    description = "Reload configuration settings from files and environment variables"
-    
-    async def execute(self, **params) -> ReloadSettingsResult:
-        """
-        Execute the reload settings command.
-        
-        Args:
-            **params: Command parameters (not used)
-            
-        Returns:
-            ReloadSettingsResult with operation status
-        """
-        logger = get_logger("reload_settings_command")
-        
-        try:
-            logger.info("🔄 Starting settings reload...")
-            
-            # Reload configuration from files and environment variables
-            reload_settings()
-            
-            # Get current custom settings
-            custom_settings = get_custom_settings()
-            
-            logger.info("✅ Settings reloaded successfully")
-            logger.info(f"📋 Current custom settings: {custom_settings}")
-            
-            return ReloadSettingsResult(
-                success=True,
-                message="Settings reloaded successfully from configuration files and environment variables",
-                custom_settings=custom_settings
-            )
-            
-        except Exception as e:
-            error_msg = f"Failed to reload settings: {str(e)}"
-            logger.error(f"❌ {error_msg}")
-            
-            return ReloadSettingsResult(
-                success=False,
-                message="Failed to reload settings",
-                custom_settings=get_custom_settings(),
-                error_message=error_msg
-            )
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Get JSON schema for the command parameters."""
-        return {
-            "type": "object",
-            "description": "Reload configuration settings from files and environment variables",
-            "properties": {},
-            "additionalProperties": False
-        } 

mcp_proxy_adapter/examples/__init__.py

@@ -1,7 +0,0 @@
-"""
-MCP Proxy Adapter Examples
-
-This package contains examples and templates for using the MCP Proxy Adapter framework.
-"""
-
-__version__ = "1.0.0" 

mcp_proxy_adapter/examples/basic_server/README.md

@@ -1,60 +0,0 @@
-# Basic Server Example
-
-A minimal example of MCP Proxy Adapter server without additional commands.
-
-## Features
-
-This example demonstrates:
-- Basic server setup
-- Built-in commands only (help, health)
-- Default configuration
-- No custom commands
-
-## Available Commands
-
-- `help` - Get information about available commands
-- `health` - Get server health status
-
-## Usage
-
-### Run the server
-
-```bash
-python server.py
-```
-
-### Test the server
-
-```bash
-# Get help
-curl -X POST http://localhost:8000/cmd \
-  -H "Content-Type: application/json" \
-  -d '{"command": "help"}'
-
-# Get health status
-curl -X POST http://localhost:8000/cmd \
-  -H "Content-Type: application/json" \
-  -d '{"command": "health"}'
-```
-
-## API Endpoints
-
-- `POST /cmd` - Execute commands
-- `GET /health` - Health check
-- `GET /commands` - List available commands
-- `GET /docs` - API documentation
-
-## Configuration
-
-The server uses default configuration. You can customize it by:
-
-1. Creating a `config.json` file
-2. Setting environment variables
-3. Passing configuration to `create_app()`
-
-## Notes
-
-- This is the simplest possible setup
-- No custom commands are registered
-- Uses framework defaults
-- Good starting point for understanding the framework 

mcp_proxy_adapter/examples/basic_server/__init__.py

@@ -1,7 +0,0 @@
-"""
-Basic Server Example
-
-A minimal example of MCP Proxy Adapter server without additional commands.
-"""
-
-__version__ = "1.0.0" 

mcp_proxy_adapter/examples/basic_server/basic_custom_settings.json

@@ -1,39 +0,0 @@
-{
-  "application": {
-    "name": "Basic MCP Proxy Server with Custom Settings",
-    "version": "1.1.0",
-    "environment": "development",
-    "description": "Basic server demonstrating custom settings usage"
-  },
-  "features": {
-    "basic_logging": true,
-    "simple_commands": true,
-    "custom_settings_demo": true,
-    "file_based_config": true
-  },
-  "server_info": {
-    "description": "Basic server with file-based custom settings",
-    "author": "MCP Proxy Adapter Team",
-    "contact": "support@example.com",
-    "documentation": "https://example.com/docs"
-  },
-  "demo_settings": {
-    "welcome_message": "Welcome to Basic MCP Proxy Server with Custom Settings!",
-    "max_connections": 150,
-    "timeout": 45,
-    "debug_mode": true,
-    "log_level": "INFO"
-  },
-  "performance": {
-    "enable_caching": true,
-    "cache_ttl": 300,
-    "max_cache_size": 1000
-  },
-  "security": {
-    "enable_rate_limiting": false,
-    "max_request_size": "5MB",
-    "allowed_origins": [
-      "*"
-    ]
-  }
-}

mcp_proxy_adapter/examples/basic_server/config.json

@@ -1,35 +0,0 @@
-{
-  "server": {
-    "host": "127.0.0.1",
-    "port": 8000,
-    "debug": true,
-    "log_level": "DEBUG"
-  },
-  "logging": {
-    "level": "DEBUG",
-    "log_dir": "./logs/basic_server",
-    "log_file": "basic_server.log",
-    "error_log_file": "basic_server_error.log",
-    "access_log_file": "basic_server_access.log",
-    "max_file_size": "5MB",
-    "backup_count": 3,
-    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    "date_format": "%Y-%m-%d %H:%M:%S",
-    "console_output": true,
-    "file_output": true
-  },
-  "commands": {
-    "auto_discovery": true,
-    "discovery_path": "mcp_proxy_adapter.commands",
-    "custom_commands_path": null
-  },
-  "custom": {
-    "server_name": "Basic MCP Proxy Server",
-    "description": "Simple example server with basic configuration",
-    "features": {
-      "hooks_enabled": false,
-      "custom_commands_enabled": false,
-      "advanced_logging": false
-    }
-  }
-} 

mcp_proxy_adapter/examples/basic_server/custom_settings_example.py

@@ -1,238 +0,0 @@
-"""
-Custom Settings Example for Basic Server
-
-This example demonstrates how to use custom settings in a basic server.
-"""
-
-import json
-import os
-from mcp_proxy_adapter.core.settings import (
-    add_custom_settings,
-    get_custom_setting_value,
-    set_custom_setting_value,
-    get_custom_settings
-)
-from mcp_proxy_adapter.core.logging import get_logger
-
-
-def setup_basic_custom_settings():
-    """
-    Setup basic custom settings for the basic server example.
-    
-    This demonstrates how to add custom settings to the framework
-    and access them throughout the application.
-    """
-    logger = get_logger("basic_server_custom_settings")
-    
-    # Define basic custom settings
-    basic_settings = {
-        "application": {
-            "name": "Basic MCP Proxy Server",
-            "version": "1.0.0",
-            "environment": "development"
-        },
-        "features": {
-            "basic_logging": True,
-            "simple_commands": True,
-            "custom_settings_demo": True
-        },
-        "server_info": {
-            "description": "Basic server with custom settings example",
-            "author": "MCP Proxy Adapter Team",
-            "contact": "support@example.com"
-        },
-        "demo_settings": {
-            "welcome_message": "Welcome to Basic MCP Proxy Server!",
-            "max_connections": 100,
-            "timeout": 30,
-            "debug_mode": True
-        }
-    }
-    
-    # Add settings to the framework
-    add_custom_settings(basic_settings)
-    
-    logger.info("✅ Basic custom settings loaded")
-    logger.info(f"📋 Application: {basic_settings['application']['name']} v{basic_settings['application']['version']}")
-    logger.info(f"🔧 Features: {list(basic_settings['features'].keys())}")
-    
-    return basic_settings
-
-
-def demonstrate_custom_settings_usage():
-    """
-    Demonstrate how to use custom settings in the application.
-    """
-    logger = get_logger("basic_server_custom_settings")
-    
-    # Get specific settings
-    app_name = get_custom_setting_value("application.name", "Unknown")
-    app_version = get_custom_setting_value("application.version", "0.0.0")
-    welcome_msg = get_custom_setting_value("demo_settings.welcome_message", "Hello!")
-    max_connections = get_custom_setting_value("demo_settings.max_connections", 50)
-    
-    logger.info(f"🏷️  Application: {app_name} v{app_version}")
-    logger.info(f"💬 Welcome Message: {welcome_msg}")
-    logger.info(f"🔗 Max Connections: {max_connections}")
-    
-    # Check if features are enabled
-    features = get_custom_setting_value("features", {})
-    enabled_features = [name for name, enabled in features.items() if enabled]
-    
-    logger.info(f"✅ Enabled Features: {', '.join(enabled_features)}")
-    
-    # Set a new custom setting
-    set_custom_setting_value("demo_settings.last_updated", "2025-08-08")
-    logger.info("🔧 Set new custom setting: demo_settings.last_updated")
-    
-    # Get all custom settings
-    all_custom_settings = get_custom_settings()
-    logger.info(f"📊 Total custom settings: {len(all_custom_settings)} sections")
-    
-    return {
-        "app_name": app_name,
-        "app_version": app_version,
-        "welcome_message": welcome_msg,
-        "max_connections": max_connections,
-        "enabled_features": enabled_features,
-        "total_settings_sections": len(all_custom_settings)
-    }
-
-
-def create_custom_settings_file():
-    """
-    Create a custom settings JSON file for the basic server.
-    """
-    custom_settings = {
-        "application": {
-            "name": "Basic MCP Proxy Server with Custom Settings",
-            "version": "1.1.0",
-            "environment": "development",
-            "description": "Basic server demonstrating custom settings usage"
-        },
-        "features": {
-            "basic_logging": True,
-            "simple_commands": True,
-            "custom_settings_demo": True,
-            "file_based_config": True
-        },
-        "server_info": {
-            "description": "Basic server with file-based custom settings",
-            "author": "MCP Proxy Adapter Team",
-            "contact": "support@example.com",
-            "documentation": "https://example.com/docs"
-        },
-        "demo_settings": {
-            "welcome_message": "Welcome to Basic MCP Proxy Server with Custom Settings!",
-            "max_connections": 150,
-            "timeout": 45,
-            "debug_mode": True,
-            "log_level": "INFO"
-        },
-        "performance": {
-            "enable_caching": True,
-            "cache_ttl": 300,
-            "max_cache_size": 1000
-        },
-        "security": {
-            "enable_rate_limiting": False,
-            "max_request_size": "5MB",
-            "allowed_origins": ["*"]
-        }
-    }
-    
-    # Write to file
-    settings_file = "basic_custom_settings.json"
-    with open(settings_file, 'w', encoding='utf-8') as f:
-        json.dump(custom_settings, f, indent=2, ensure_ascii=False)
-    
-    print(f"✅ Created custom settings file: {settings_file}")
-    return settings_file
-
-
-def load_custom_settings_from_file(file_path: str = "basic_custom_settings.json"):
-    """
-    Load custom settings from a JSON file.
-    
-    Args:
-        file_path: Path to the custom settings JSON file
-    """
-    logger = get_logger("basic_server_custom_settings")
-    
-    try:
-        if os.path.exists(file_path):
-            with open(file_path, 'r', encoding='utf-8') as f:
-                custom_settings = json.load(f)
-            
-            # Add to framework
-            add_custom_settings(custom_settings)
-            
-            logger.info(f"📁 Loaded custom settings from: {file_path}")
-            logger.info(f"📋 Application: {custom_settings.get('application', {}).get('name', 'Unknown')}")
-            
-            return custom_settings
-        else:
-            logger.warning(f"⚠️  Custom settings file not found: {file_path}")
-            return None
-            
-    except Exception as e:
-        logger.error(f"❌ Failed to load custom settings from {file_path}: {e}")
-        return None
-
-
-def print_custom_settings_summary():
-    """
-    Print a summary of current custom settings.
-    """
-    logger = get_logger("basic_server_custom_settings")
-    
-    all_settings = get_custom_settings()
-    
-    logger.info("📊 Custom Settings Summary:")
-    
-    # Application info
-    app_name = get_custom_setting_value("application.name", "Unknown")
-    app_version = get_custom_setting_value("application.version", "0.0.0")
-    logger.info(f"   Application: {app_name} v{app_version}")
-    
-    # Features
-    features = get_custom_setting_value("features", {})
-    enabled_features = [name for name, enabled in features.items() if enabled]
-    logger.info(f"   Enabled Features: {', '.join(enabled_features) if enabled_features else 'None'}")
-    
-    # Demo settings
-    welcome_msg = get_custom_setting_value("demo_settings.welcome_message", "Hello!")
-    max_connections = get_custom_setting_value("demo_settings.max_connections", 50)
-    logger.info(f"   Welcome Message: {welcome_msg}")
-    logger.info(f"   Max Connections: {max_connections}")
-    
-    # Performance
-    caching_enabled = get_custom_setting_value("performance.enable_caching", False)
-    logger.info(f"   Caching: {'Enabled' if caching_enabled else 'Disabled'}")
-    
-    # Security
-    rate_limiting = get_custom_setting_value("security.enable_rate_limiting", False)
-    logger.info(f"   Rate Limiting: {'Enabled' if rate_limiting else 'Disabled'}")
-    
-    logger.info(f"   Total Settings Sections: {len(all_settings)}")
-
-
-if __name__ == "__main__":
-    # Setup basic custom settings
-    setup_basic_custom_settings()
-    
-    # Demonstrate usage
-    demo_info = demonstrate_custom_settings_usage()
-    
-    # Create custom settings file
-    settings_file = create_custom_settings_file()
-    
-    # Load from file
-    load_custom_settings_from_file(settings_file)
-    
-    # Print summary
-    print_custom_settings_summary()
-    
-    print("\n🎉 Custom settings demonstration completed!")
-    print(f"📁 Custom settings file: {settings_file}")
-    print("🔧 You can now use these settings in your basic server application.")