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

mcp_proxy_adapter/core/logging.py

@@ -122,15 +122,28 @@ def setup_logging(
     # Get parameters from configuration if not explicitly specified
     level = level or config.get("logging.level", "INFO")
     log_file = log_file or config.get("logging.file")
-    rotation_type = rotation_type or config.get("logging.rotation.type", "size")
+    rotation_type = rotation_type or "size"  # Default to size-based rotation
     
-    # Size-based rotation parameters
-    max_bytes = max_bytes or config.get("logging.rotation.max_bytes", 10 * 1024 * 1024)  # 10 MB by default
-    backup_count = backup_count or config.get("logging.rotation.backup_count", 5)
+    # Get log directory and file settings from config
+    log_dir = config.get("logging.log_dir", "./logs")
+    log_file_name = config.get("logging.log_file", "mcp_proxy_adapter.log")
+    error_log_file = config.get("logging.error_log_file", "mcp_proxy_adapter_error.log")
+    access_log_file = config.get("logging.access_log_file", "mcp_proxy_adapter_access.log")
     
-    # Time-based rotation parameters
-    rotation_when = rotation_when or config.get("logging.rotation.when", "D")  # Daily by default
-    rotation_interval = rotation_interval or config.get("logging.rotation.interval", 1)
+    # Get rotation settings from config
+    max_file_size_str = config.get("logging.max_file_size", "10MB")
+    backup_count = backup_count or config.get("logging.backup_count", 5)
+    
+    # Parse max file size (e.g., "10MB" -> 10 * 1024 * 1024)
+    max_bytes = max_bytes or _parse_file_size(max_file_size_str)
+    
+    # Get format settings
+    log_format = config.get("logging.format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    date_format = config.get("logging.date_format", "%Y-%m-%d %H:%M:%S")
+    
+    # Get output settings
+    console_output = config.get("logging.console_output", True)
+    file_output = config.get("logging.file_output", True)
 
     # Convert string logging level to constant
     numeric_level = getattr(logging, level.upper(), None)
@@ -142,42 +155,60 @@ def setup_logging(
     logger.setLevel(numeric_level)
     logger.handlers = []  # Clear handlers in case of repeated call
 
-    # Create console handler
-    console_handler = logging.StreamHandler(sys.stdout)
-    console_handler.setLevel(numeric_level)
-    console_handler.setFormatter(CustomFormatter())
-    logger.addHandler(console_handler)
-
-    # Create file handler if file specified
-    if log_file:
-        # Create directory for log file if it doesn't exist
-        log_dir = os.path.dirname(log_file)
-        if log_dir and not os.path.exists(log_dir):
+    # Create formatter
+    formatter = logging.Formatter(log_format, date_format)
+
+    # Create console handler if enabled
+    if console_output:
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setLevel(numeric_level)
+        console_handler.setFormatter(CustomFormatter())
+        logger.addHandler(console_handler)
+
+    # Create file handlers if file output is enabled
+    if file_output and log_dir:
+        # Create directory for log files if it doesn't exist
+        if not os.path.exists(log_dir):
             os.makedirs(log_dir, exist_ok=True)
 
-        # Choose rotation type
-        if rotation_type.lower() == "time":
-            file_handler = TimedRotatingFileHandler(
-                log_file,
-                when=rotation_when,
-                interval=rotation_interval,
+        # Main log file
+        if log_file_name:
+            main_log_path = os.path.join(log_dir, log_file_name)
+            main_handler = RotatingFileHandler(
+                main_log_path,
+                maxBytes=max_bytes,
+                backupCount=backup_count,
+                encoding="utf-8"
+            )
+            main_handler.setLevel(numeric_level)
+            main_handler.setFormatter(formatter)
+            logger.addHandler(main_handler)
+
+        # Error log file
+        if error_log_file:
+            error_log_path = os.path.join(log_dir, error_log_file)
+            error_handler = RotatingFileHandler(
+                error_log_path,
+                maxBytes=max_bytes,
                 backupCount=backup_count,
                 encoding="utf-8"
             )
-        else:  # Default to size-based rotation
-            file_handler = RotatingFileHandler(
-                log_file,
+            error_handler.setLevel(logging.ERROR)
+            error_handler.setFormatter(formatter)
+            logger.addHandler(error_handler)
+
+        # Access log file (for HTTP requests)
+        if access_log_file:
+            access_log_path = os.path.join(log_dir, access_log_file)
+            access_handler = RotatingFileHandler(
+                access_log_path,
                 maxBytes=max_bytes,
                 backupCount=backup_count,
                 encoding="utf-8"
             )
-            
-        file_handler.setLevel(numeric_level)
-        file_formatter = logging.Formatter(
-            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-        )
-        file_handler.setFormatter(file_formatter)
-        logger.addHandler(file_handler)
+            access_handler.setLevel(logging.INFO)
+            access_handler.setFormatter(formatter)
+            logger.addHandler(access_handler)
 
     # Configure loggers for external libraries
     log_levels = config.get("logging.levels", {})
@@ -188,6 +219,28 @@ def setup_logging(
     return logger
 
 
+def _parse_file_size(size_str: str) -> int:
+    """
+    Parse file size string to bytes.
+    
+    Args:
+        size_str: Size string (e.g., "10MB", "1GB", "100KB")
+        
+    Returns:
+        Size in bytes
+    """
+    size_str = size_str.upper()
+    if size_str.endswith("KB"):
+        return int(size_str[:-2]) * 1024
+    elif size_str.endswith("MB"):
+        return int(size_str[:-2]) * 1024 * 1024
+    elif size_str.endswith("GB"):
+        return int(size_str[:-2]) * 1024 * 1024 * 1024
+    else:
+        # Assume bytes if no unit specified
+        return int(size_str)
+
+
 def get_logger(name: str) -> logging.Logger:
     """
     Get a logger with the specified name.

mcp_proxy_adapter/core/settings.py

@@ -0,0 +1,376 @@
+"""
+Settings management for the MCP Proxy Adapter framework.
+Provides utilities for reading and managing framework settings from configuration.
+"""
+
+from typing import Any, Dict, Optional, Union
+from mcp_proxy_adapter.config import config
+
+
+class Settings:
+    """
+    Settings management class for the framework.
+    Provides easy access to configuration values with type conversion and validation.
+    """
+    
+    # Store custom settings as a class variable
+    _custom_settings: Dict[str, Any] = {}
+    
+    @classmethod
+    def add_custom_settings(cls, settings: Dict[str, Any]) -> None:
+        """
+        Add custom settings to the settings manager.
+        
+        Args:
+            settings: Dictionary with custom settings
+        """
+        cls._custom_settings.update(settings)
+    
+    @classmethod
+    def get_custom_settings(cls) -> Dict[str, Any]:
+        """
+        Get all custom settings.
+        
+        Returns:
+            Dictionary with all custom settings
+        """
+        return cls._custom_settings.copy()
+    
+    @classmethod
+    def get_custom_setting_value(cls, key: str, default: Any = None) -> Any:
+        """
+        Get custom setting value.
+        
+        Args:
+            key: Setting key
+            default: Default value if key not found
+            
+        Returns:
+            Setting value
+        """
+        return cls._custom_settings.get(key, default)
+    
+    @classmethod
+    def set_custom_setting_value(cls, key: str, value: Any) -> None:
+        """
+        Set custom setting value.
+        
+        Args:
+            key: Setting key
+            value: Value to set
+        """
+        cls._custom_settings[key] = value
+    
+    @classmethod
+    def clear_custom_settings(cls) -> None:
+        """
+        Clear all custom settings.
+        """
+        cls._custom_settings.clear()
+    
+    @staticmethod
+    def get_server_settings() -> Dict[str, Any]:
+        """
+        Get server configuration settings.
+        
+        Returns:
+            Dictionary with server settings
+        """
+        return {
+            "host": config.get("server.host", "0.0.0.0"),
+            "port": config.get("server.port", 8000),
+            "debug": config.get("server.debug", False),
+            "log_level": config.get("server.log_level", "INFO")
+        }
+    
+    @staticmethod
+    def get_logging_settings() -> Dict[str, Any]:
+        """
+        Get logging configuration settings.
+        
+        Returns:
+            Dictionary with logging settings
+        """
+        return {
+            "level": config.get("logging.level", "INFO"),
+            "file": config.get("logging.file"),
+            "log_dir": config.get("logging.log_dir", "./logs"),
+            "log_file": config.get("logging.log_file", "mcp_proxy_adapter.log"),
+            "error_log_file": config.get("logging.error_log_file", "mcp_proxy_adapter_error.log"),
+            "access_log_file": config.get("logging.access_log_file", "mcp_proxy_adapter_access.log"),
+            "max_file_size": config.get("logging.max_file_size", "10MB"),
+            "backup_count": config.get("logging.backup_count", 5),
+            "format": config.get("logging.format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s"),
+            "date_format": config.get("logging.date_format", "%Y-%m-%d %H:%M:%S"),
+            "console_output": config.get("logging.console_output", True),
+            "file_output": config.get("logging.file_output", True)
+        }
+    
+    @staticmethod
+    def get_commands_settings() -> Dict[str, Any]:
+        """
+        Get commands configuration settings.
+        
+        Returns:
+            Dictionary with commands settings
+        """
+        return {
+            "auto_discovery": config.get("commands.auto_discovery", True),
+            "discovery_path": config.get("commands.discovery_path", "mcp_proxy_adapter.commands"),
+            "custom_commands_path": config.get("commands.custom_commands_path")
+        }
+    
+    @staticmethod
+    def get_custom_setting(key: str, default: Any = None) -> Any:
+        """
+        Get custom setting from configuration.
+        
+        Args:
+            key: Configuration key in dot notation (e.g., "custom.feature_enabled")
+            default: Default value if key not found
+            
+        Returns:
+            Configuration value
+        """
+        return config.get(key, default)
+    
+    @staticmethod
+    def get_all_settings() -> Dict[str, Any]:
+        """
+        Get all configuration settings including custom settings.
+        
+        Returns:
+            Dictionary with all configuration settings
+        """
+        all_settings = config.get_all()
+        all_settings['custom_settings'] = Settings._custom_settings
+        return all_settings
+    
+    @staticmethod
+    def set_custom_setting(key: str, value: Any) -> None:
+        """
+        Set custom setting in configuration.
+        
+        Args:
+            key: Configuration key in dot notation
+            value: Value to set
+        """
+        config.set(key, value)
+    
+    @staticmethod
+    def reload_config() -> None:
+        """
+        Reload configuration from file and environment variables.
+        """
+        config.load_config()
+
+
+class ServerSettings:
+    """
+    Server-specific settings helper.
+    """
+    
+    @staticmethod
+    def get_host() -> str:
+        """Get server host."""
+        return config.get("server.host", "0.0.0.0")
+    
+    @staticmethod
+    def get_port() -> int:
+        """Get server port."""
+        return config.get("server.port", 8000)
+    
+    @staticmethod
+    def get_debug() -> bool:
+        """Get debug mode."""
+        return config.get("server.debug", False)
+    
+    @staticmethod
+    def get_log_level() -> str:
+        """Get log level."""
+        return config.get("server.log_level", "INFO")
+
+
+class LoggingSettings:
+    """
+    Logging-specific settings helper.
+    """
+    
+    @staticmethod
+    def get_level() -> str:
+        """Get logging level."""
+        return config.get("logging.level", "INFO")
+    
+    @staticmethod
+    def get_log_dir() -> str:
+        """Get log directory."""
+        return config.get("logging.log_dir", "./logs")
+    
+    @staticmethod
+    def get_log_file() -> Optional[str]:
+        """Get main log file name."""
+        return config.get("logging.log_file", "mcp_proxy_adapter.log")
+    
+    @staticmethod
+    def get_error_log_file() -> Optional[str]:
+        """Get error log file name."""
+        return config.get("logging.error_log_file", "mcp_proxy_adapter_error.log")
+    
+    @staticmethod
+    def get_access_log_file() -> Optional[str]:
+        """Get access log file name."""
+        return config.get("logging.access_log_file", "mcp_proxy_adapter_access.log")
+    
+    @staticmethod
+    def get_max_file_size() -> str:
+        """Get max file size."""
+        return config.get("logging.max_file_size", "10MB")
+    
+    @staticmethod
+    def get_backup_count() -> int:
+        """Get backup count."""
+        return config.get("logging.backup_count", 5)
+    
+    @staticmethod
+    def get_format() -> str:
+        """Get log format."""
+        return config.get("logging.format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    
+    @staticmethod
+    def get_date_format() -> str:
+        """Get date format."""
+        return config.get("logging.date_format", "%Y-%m-%d %H:%M:%S")
+    
+    @staticmethod
+    def get_console_output() -> bool:
+        """Get console output setting."""
+        return config.get("logging.console_output", True)
+    
+    @staticmethod
+    def get_file_output() -> bool:
+        """Get file output setting."""
+        return config.get("logging.file_output", True)
+
+
+class CommandsSettings:
+    """
+    Commands-specific settings helper.
+    """
+    
+    @staticmethod
+    def get_auto_discovery() -> bool:
+        """Get auto discovery setting."""
+        return config.get("commands.auto_discovery", True)
+    
+    @staticmethod
+    def get_discovery_path() -> str:
+        """Get discovery path."""
+        return config.get("commands.discovery_path", "mcp_proxy_adapter.commands")
+    
+    @staticmethod
+    def get_custom_commands_path() -> Optional[str]:
+        """Get custom commands path."""
+        return config.get("commands.custom_commands_path")
+
+
+# Convenience functions for easy access
+def get_server_host() -> str:
+    """Get server host."""
+    return ServerSettings.get_host()
+
+
+def get_server_port() -> int:
+    """Get server port."""
+    return ServerSettings.get_port()
+
+
+def get_server_debug() -> bool:
+    """Get server debug mode."""
+    return ServerSettings.get_debug()
+
+
+def get_logging_level() -> str:
+    """Get logging level."""
+    return LoggingSettings.get_level()
+
+
+def get_logging_dir() -> str:
+    """Get logging directory."""
+    return LoggingSettings.get_log_dir()
+
+
+def get_auto_discovery() -> bool:
+    """Get auto discovery setting."""
+    return CommandsSettings.get_auto_discovery()
+
+
+def get_discovery_path() -> str:
+    """Get discovery path."""
+    return CommandsSettings.get_discovery_path()
+
+
+def get_setting(key: str, default: Any = None) -> Any:
+    """Get any setting by key."""
+    return Settings.get_custom_setting(key, default)
+
+
+def set_setting(key: str, value: Any) -> None:
+    """Set any setting by key."""
+    Settings.set_custom_setting(key, value)
+
+
+def reload_settings() -> None:
+    """Reload all settings from configuration."""
+    Settings.reload_config()
+
+
+def add_custom_settings(settings: Dict[str, Any]) -> None:
+    """
+    Add custom settings to the settings manager.
+    
+    Args:
+        settings: Dictionary with custom settings
+    """
+    Settings.add_custom_settings(settings)
+
+
+def get_custom_settings() -> Dict[str, Any]:
+    """
+    Get all custom settings.
+    
+    Returns:
+        Dictionary with all custom settings
+    """
+    return Settings.get_custom_settings()
+
+
+def get_custom_setting_value(key: str, default: Any = None) -> Any:
+    """
+    Get custom setting value.
+    
+    Args:
+        key: Setting key
+        default: Default value if key not found
+        
+    Returns:
+        Setting value
+    """
+    return Settings.get_custom_setting_value(key, default)
+
+
+def set_custom_setting_value(key: str, value: Any) -> None:
+    """
+    Set custom setting value.
+    
+    Args:
+        key: Setting key
+        value: Value to set
+    """
+    Settings.set_custom_setting_value(key, value)
+
+
+def clear_custom_settings() -> None:
+    """
+    Clear all custom settings.
+    """
+    Settings.clear_custom_settings() 

mcp_proxy_adapter/core/utils.py

@@ -8,7 +8,7 @@ import os
 import sys
 import time
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 from mcp_proxy_adapter.core.logging import logger
@@ -45,7 +45,7 @@ def format_datetime(dt: Optional[datetime] = None, format_str: str = "%Y-%m-%dT%
     Returns:
         Formatted date/time string.
     """
-    dt = dt or datetime.utcnow()
+    dt = dt or datetime.now(timezone.utc)
     return dt.strftime(format_str)
 
 

mcp_proxy_adapter/custom_openapi.py

@@ -4,7 +4,7 @@ Custom OpenAPI schema generator for MCP Microservice compatible with MCP-Proxy.
 import json
 from copy import deepcopy
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Type
+from typing import Any, Dict, List, Optional, Set, Type, Callable
 
 from fastapi import FastAPI
 from fastapi.openapi.utils import get_openapi
@@ -55,6 +55,15 @@ class CustomOpenAPIGenerator:
         # Get all commands from the registry
         commands = registry.get_all_commands()
         
+        # Ensure CommandRequest exists in schemas
+        if "CommandRequest" not in schema["components"]["schemas"]:
+            schema["components"]["schemas"]["CommandRequest"] = {
+                "properties": {
+                    "command": {"type": "string", "enum": []},
+                    "params": {"type": "object", "oneOf": []}
+                }
+            }
+        
         # Add command names to the CommandRequest enum
         schema["components"]["schemas"]["CommandRequest"]["properties"]["command"]["enum"] = [
             cmd for cmd in commands.keys()
@@ -284,4 +293,74 @@ def custom_openapi(app: FastAPI) -> Dict[str, Any]:
     # Cache the schema
     app.openapi_schema = openapi_schema
 
-    return openapi_schema 
+    return openapi_schema
+
+
+# Registry for custom OpenAPI generators
+_openapi_generators: Dict[str, Callable] = {}
+
+
+def register_openapi_generator(name: str, generator_func: Callable[[FastAPI], Dict[str, Any]]) -> None:
+    """
+    Register a custom OpenAPI generator.
+    
+    Args:
+        name: Generator name.
+        generator_func: Function that generates OpenAPI schema.
+    """
+    _openapi_generators[name] = generator_func
+    logger.info(f"Registered custom OpenAPI generator: {name}")
+
+
+def get_openapi_generator(name: str) -> Optional[Callable[[FastAPI], Dict[str, Any]]]:
+    """
+    Get a custom OpenAPI generator by name.
+    
+    Args:
+        name: Generator name.
+        
+    Returns:
+        Generator function or None if not found.
+    """
+    return _openapi_generators.get(name)
+
+
+def list_openapi_generators() -> List[str]:
+    """
+    Get list of registered OpenAPI generators.
+    
+    Returns:
+        List of generator names.
+    """
+    return list(_openapi_generators.keys())
+
+
+def custom_openapi_with_fallback(app: FastAPI) -> Dict[str, Any]:
+    """
+    EN:
+    Create a custom OpenAPI schema for the FastAPI application.
+    Checks for custom generators first, then falls back to default generator.
+    Passes app's title, description, and version to the generator.
+
+    RU:
+    Создаёт кастомную OpenAPI-схему для FastAPI-приложения.
+    Сначала проверяет наличие кастомных генераторов, затем использует встроенный генератор.
+    Передаёт параметры title, description и version из приложения в генератор схемы.
+    
+    Args:
+        app: The FastAPI application / FastAPI-приложение
+        
+    Returns:
+        Dict containing the custom OpenAPI schema / Словарь с кастомной OpenAPI-схемой
+    """
+    # Check if there are any custom generators
+    if _openapi_generators:
+        # Use the first registered generator
+        generator_name = list(_openapi_generators.keys())[0]
+        generator_func = _openapi_generators[generator_name]
+        logger.info(f"Using custom OpenAPI generator: {generator_name}")
+        return generator_func(app)
+    
+    # Fall back to default generator
+    logger.info("Using default OpenAPI generator")
+    return custom_openapi(app)