mcp-proxy-adapter 6.3.3__py3-none-any.whl → 6.3.5__py3-none-any.whl

mcp_proxy_adapter/core/server_engine.py

@@ -19,54 +19,54 @@ logger = logging.getLogger(__name__)
 class ServerEngine(ABC):
     """
     Abstract base class for server engines.
-    
+
     This class defines the interface that all server engines must implement,
     allowing the framework to work with different ASGI servers transparently.
     """
-    
+
     @abstractmethod
     def get_name(self) -> str:
         """Get the name of the server engine."""
         pass
-    
+
     @abstractmethod
     def get_supported_features(self) -> Dict[str, bool]:
         """
         Get supported features of this server engine.
-        
+
         Returns:
             Dictionary mapping feature names to boolean support status
         """
         pass
-    
+
     @abstractmethod
     def get_config_schema(self) -> Dict[str, Any]:
         """
         Get configuration schema for this server engine.
-        
+
         Returns:
             Dictionary describing the configuration options
         """
         pass
-    
+
     @abstractmethod
     def validate_config(self, config: Dict[str, Any]) -> bool:
         """
         Validate configuration for this server engine.
-        
+
         Args:
             config: Configuration dictionary
-            
+
         Returns:
             True if configuration is valid, False otherwise
         """
         pass
-    
+
     @abstractmethod
     def run_server(self, app: Any, config: Dict[str, Any]) -> None:
         """
         Run the server with the given configuration.
-        
+
         Args:
             app: ASGI application
             config: Server configuration
@@ -77,24 +77,24 @@ class ServerEngine(ABC):
 class HypercornEngine(ServerEngine):
     """
     Hypercorn server engine implementation.
-    
+
     Provides full mTLS support and better SSL capabilities.
     """
-    
+
     def get_name(self) -> str:
         return "hypercorn"
-    
+
     def get_supported_features(self) -> Dict[str, bool]:
         return {
             "ssl_tls": True,
-            "mtls_client_certs": True,   # Full support
-            "ssl_scope_info": True,      # SSL info in request scope
+            "mtls_client_certs": True,  # Full support
+            "ssl_scope_info": True,  # SSL info in request scope
             "client_cert_verification": True,
             "websockets": True,
             "http2": True,
-            "reload": True
+            "reload": True,
         }
-    
+
     def get_config_schema(self) -> Dict[str, Any]:
         return {
             "host": {"type": "string", "default": "127.0.0.1"},
@@ -105,18 +105,18 @@ class HypercornEngine(ServerEngine):
             "ca_certs": {"type": "string", "optional": True},
             "verify_mode": {"type": "string", "optional": True},
             "reload": {"type": "boolean", "default": False},
-            "workers": {"type": "integer", "optional": True}
+            "workers": {"type": "integer", "optional": True},
         }
-    
+
     def validate_config(self, config: Dict[str, Any]) -> bool:
         """Validate hypercorn configuration."""
         required_fields = ["host", "port"]
-        
+
         for field in required_fields:
             if field not in config:
                 logger.error(f"Missing required field: {field}")
                 return False
-        
+
         # Validate SSL files exist if specified
         ssl_files = ["certfile", "keyfile", "ca_certs"]
         for ssl_file in ssl_files:
@@ -124,29 +124,37 @@ class HypercornEngine(ServerEngine):
                 if not Path(config[ssl_file]).exists():
                     logger.error(f"SSL file not found: {config[ssl_file]}")
                     return False
-        
+
         return True
-    
+
     def run_server(self, app: Any, config: Dict[str, Any]) -> None:
         """Run hypercorn server."""
         try:
             import hypercorn.asyncio
             import asyncio
-            
+
             # Prepare hypercorn config
             hypercorn_config = {
                 "bind": f"{config.get('host', '127.0.0.1')}:{config.get('port', 8000)}",
                 "log_level": config.get("log_level", "INFO"),
-                "reload": config.get("reload", False)
+                "reload": config.get("reload", False),
             }
-            
+
             # Add SSL configuration if provided
             logger.info(f"🔍 DEBUG: Input config keys: {list(config.keys())}")
-            logger.info(f"🔍 DEBUG: Input config certfile: {config.get('certfile', 'NOT_FOUND')}")
-            logger.info(f"🔍 DEBUG: Input config keyfile: {config.get('keyfile', 'NOT_FOUND')}")
-            logger.info(f"🔍 DEBUG: Input config ca_certs: {config.get('ca_certs', 'NOT_FOUND')}")
-            logger.info(f"🔍 DEBUG: Input config verify_mode: {config.get('verify_mode', 'NOT_FOUND')}")
-            
+            logger.info(
+                f"🔍 DEBUG: Input config certfile: {config.get('certfile', 'NOT_FOUND')}"
+            )
+            logger.info(
+                f"🔍 DEBUG: Input config keyfile: {config.get('keyfile', 'NOT_FOUND')}"
+            )
+            logger.info(
+                f"🔍 DEBUG: Input config ca_certs: {config.get('ca_certs', 'NOT_FOUND')}"
+            )
+            logger.info(
+                f"🔍 DEBUG: Input config verify_mode: {config.get('verify_mode', 'NOT_FOUND')}"
+            )
+
             if "certfile" in config and config["certfile"]:
                 hypercorn_config["certfile"] = config["certfile"]
             if "keyfile" in config and config["keyfile"]:
@@ -158,34 +166,43 @@ class HypercornEngine(ServerEngine):
                 verify_mode_str = config["verify_mode"]
                 if verify_mode_str == "CERT_NONE":
                     import ssl
+
                     hypercorn_config["verify_mode"] = ssl.CERT_NONE
                 elif verify_mode_str == "CERT_REQUIRED":
                     import ssl
+
                     hypercorn_config["verify_mode"] = ssl.CERT_REQUIRED
                 elif verify_mode_str == "CERT_OPTIONAL":
                     import ssl
+
                     hypercorn_config["verify_mode"] = ssl.CERT_OPTIONAL
                 else:
                     hypercorn_config["verify_mode"] = verify_mode_str
-            
+
             # Add workers if specified
             if "workers" in config and config["workers"]:
                 hypercorn_config["workers"] = config["workers"]
-            
+
             logger.info(f"Starting hypercorn server with config: {hypercorn_config}")
             logger.info(f"SSL config from input: {config.get('ssl', 'NOT_FOUND')}")
-            logger.info(f"Security SSL config: {config.get('security', {}).get('ssl', 'NOT_FOUND')}")
-            logger.info(f"🔍 DEBUG: Hypercorn verify_mode: {hypercorn_config.get('verify_mode', 'NOT_SET')}")
-            logger.info(f"🔍 DEBUG: Hypercorn ca_certs: {hypercorn_config.get('ca_certs', 'NOT_SET')}")
-            
+            logger.info(
+                f"Security SSL config: {config.get('security', {}).get('ssl', 'NOT_FOUND')}"
+            )
+            logger.info(
+                f"🔍 DEBUG: Hypercorn verify_mode: {hypercorn_config.get('verify_mode', 'NOT_SET')}"
+            )
+            logger.info(
+                f"🔍 DEBUG: Hypercorn ca_certs: {hypercorn_config.get('ca_certs', 'NOT_SET')}"
+            )
+
             # Create config object
             config_obj = hypercorn.Config()
             for key, value in hypercorn_config.items():
                 setattr(config_obj, key, value)
-            
+
             # Run server
             asyncio.run(hypercorn.asyncio.serve(app, config_obj))
-            
+
         except ImportError:
             logger.error("hypercorn not installed. Install with: pip install hypercorn")
             raise
@@ -197,54 +214,54 @@ class HypercornEngine(ServerEngine):
 class ServerEngineFactory:
     """
     Factory for creating server engines.
-    
+
     This class manages the creation and configuration of different server engines.
     """
-    
+
     _engines: Dict[str, ServerEngine] = {}
-    
+
     @classmethod
     def register_engine(cls, engine: ServerEngine) -> None:
         """
         Register a server engine.
-        
+
         Args:
             engine: Server engine instance to register
         """
         cls._engines[engine.get_name()] = engine
         logger.info(f"Registered server engine: {engine.get_name()}")
-    
+
     @classmethod
     def get_engine(cls, name: str) -> Optional[ServerEngine]:
         """
         Get a server engine by name.
-        
+
         Args:
             name: Name of the server engine
-            
+
         Returns:
             Server engine instance or None if not found
         """
         return cls._engines.get(name)
-    
+
     @classmethod
     def get_available_engines(cls) -> Dict[str, ServerEngine]:
         """
         Get all available server engines.
-        
+
         Returns:
             Dictionary mapping engine names to engine instances
         """
         return cls._engines.copy()
-    
+
     @classmethod
     def get_engine_with_feature(cls, feature: str) -> Optional[ServerEngine]:
         """
         Get the first available engine that supports a specific feature.
-        
+
         Args:
             feature: Name of the feature to check
-            
+
         Returns:
             Server engine that supports the feature or None
         """
@@ -252,13 +269,14 @@ class ServerEngineFactory:
             if engine.get_supported_features().get(feature, False):
                 return engine
         return None
-    
+
     @classmethod
     def initialize_default_engines(cls) -> None:
         """Initialize default server engines."""
         # Register hypercorn engine (only supported engine)
         try:
             import hypercorn
+
             cls.register_engine(HypercornEngine())
             logger.info("Hypercorn engine registered (full mTLS support available)")
         except ImportError:

mcp_proxy_adapter/core/settings.py

@@ -12,67 +12,67 @@ 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
         """
@@ -80,14 +80,14 @@ class Settings:
             "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")
+            "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
         """
@@ -96,68 +96,76 @@ class Settings:
             "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"),
+            "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"),
+            "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)
+            "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"),
+            "discovery_path": config.get(
+                "commands.discovery_path", "mcp_proxy_adapter.commands"
+            ),
             "auto_commands_path": config.get("commands.auto_commands_path"),
-            "custom_commands_path": config.get("commands.custom_commands_path")
+            "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
+        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:
         """
@@ -170,22 +178,22 @@ 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."""
@@ -196,57 +204,59 @@ 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")
-    
+        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."""
@@ -257,17 +267,17 @@ 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."""
@@ -328,7 +338,7 @@ def reload_settings() -> None:
 def add_custom_settings(settings: Dict[str, Any]) -> None:
     """
     Add custom settings to the settings manager.
-    
+
     Args:
         settings: Dictionary with custom settings
     """
@@ -338,7 +348,7 @@ def add_custom_settings(settings: Dict[str, Any]) -> None:
 def get_custom_settings() -> Dict[str, Any]:
     """
     Get all custom settings.
-    
+
     Returns:
         Dictionary with all custom settings
     """
@@ -348,11 +358,11 @@ def get_custom_settings() -> Dict[str, Any]:
 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
     """
@@ -362,7 +372,7 @@ def get_custom_setting_value(key: str, default: Any = None) -> Any:
 def set_custom_setting_value(key: str, value: Any) -> None:
     """
     Set custom setting value.
-    
+
     Args:
         key: Setting key
         value: Value to set
@@ -374,4 +384,4 @@ def clear_custom_settings() -> None:
     """
     Clear all custom settings.
     """
-    Settings.clear_custom_settings() 
+    Settings.clear_custom_settings()