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

mcp_proxy_adapter/commands/config_command.py

@@ -13,45 +13,59 @@ class ConfigResult(SuccessResult):
     """
     Config operation result.
     """
-    
-    def __init__(self, config: Dict[str, Any], operation: str, message: str = None):
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        operation: str,
+        message: Optional[str] = None,
+    ):
         """
         Initialize config result.
-        
+
         Args:
             config: Configuration values
             operation: Operation performed
             message: Optional message
         """
-        super().__init__(data={
-            "config": config,
-            "operation": operation
-        }, message=message)
+        super().__init__(
+            data={"config": config, "operation": operation}, message=message
+        )
 
 
 class ConfigCommand(Command):
     """
     Command for managing service configuration.
     """
+
     name = "config"
     description = "Get or set configuration values"
     result_class = ConfigResult
-    
-    async def execute(self, operation: str = "get", path: str = None, value: Any = None) -> ConfigResult:
+
+    async def execute(
+        self,
+        operation: str = "get",
+        path: Optional[str] = None,
+        value: Any = None,
+        context: Optional[Dict] = None,
+        **kwargs,
+    ) -> ConfigResult:
         """
         Execute the command.
-        
+
         Args:
             operation: Operation to perform (get, set)
             path: Configuration path (dot notation)
             value: Value to set (for set operation)
-            
+            context: Optional context parameter passed by framework
+            **kwargs: Additional parameters
+
         Returns:
             Config operation result
         """
         message = None
         result_config = {}
-        
+
         if operation == "get":
             if path:
                 # Get specific config value
@@ -59,8 +73,8 @@ class ConfigCommand(Command):
             else:
                 # Get all config
                 result_config = config_instance.get_all()
-            message = f"Configuration retrieved successfully"
-            
+            message = "Configuration retrieved successfully"
+
         elif operation == "set":
             if path and value is not None:
                 # Set config value
@@ -68,26 +82,26 @@ class ConfigCommand(Command):
                 # Save config
                 config_instance.save()
                 result_config = {path: value}
-                message = f"Configuration updated successfully"
+                message = "Configuration updated successfully"
             else:
                 # Error - missing required parameters
-                raise ValueError("Both 'path' and 'value' are required for 'set' operation")
-                
+                raise ValueError(
+                    "Both 'path' and 'value' are required for 'set' operation"
+                )
+
         else:
             # Invalid operation
-            raise ValueError(f"Invalid operation: {operation}. Valid operations: get, set")
-        
-        return ConfigResult(
-            config=result_config,
-            operation=operation,
-            message=message
-        )
-    
+            raise ValueError(
+                f"Invalid operation: {operation}. Valid operations: get, set"
+            )
+
+        return ConfigResult(config=result_config, operation=operation, message=message)
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """
         Returns JSON schema for command parameters validation.
-        
+
         Returns:
             Dictionary with JSON schema.
         """
@@ -95,19 +109,20 @@ class ConfigCommand(Command):
             "type": "object",
             "properties": {
                 "operation": {
-                    "type": "string", 
+                    "type": "string",
                     "enum": ["get", "set"],
                     "default": "get",
-                    "description": "Operation to perform (get or set)"
+                    "description": "Operation to perform (get or set)",
                 },
                 "path": {
                     "type": "string",
-                    "description": "Configuration path in dot notation (e.g. 'server.host')"
+                    "description": "Configuration path in dot notation "
+                    "(e.g. 'server.host')",
                 },
                 "value": {
-                    "description": "Value to set (required for 'set' operation)"
-                }
+                    "description": "Value to set (required for " "'set' operation)"
+                },
             },
             "required": ["operation"],
-            "additionalProperties": False
-        } 
+            "additionalProperties": False,
+        }

mcp_proxy_adapter/commands/dependency_container.py

@@ -7,47 +7,47 @@ for command instances in the microservice.
 
 from typing import Any, Dict, Optional, Type, TypeVar, cast
 
-T = TypeVar('T')
+T = TypeVar("T")
 
 
 class DependencyContainer:
     """
     Container for managing dependencies.
-    
+
     This class provides functionality to register, resolve, and manage
     dependencies that can be injected into command instances.
     """
-    
+
     def __init__(self):
         """Initialize dependency container."""
         self._dependencies: Dict[str, Any] = {}
         self._factories: Dict[str, callable] = {}
         self._singletons: Dict[str, Any] = {}
-    
+
     def register(self, name: str, instance: Any) -> None:
         """
         Register a dependency instance with a given name.
-        
+
         Args:
             name: The name to register the dependency under
             instance: The dependency instance
         """
         self._dependencies[name] = instance
-    
+
     def register_factory(self, name: str, factory: callable) -> None:
         """
         Register a factory function that will be called to create the dependency.
-        
+
         Args:
             name: The name to register the factory under
             factory: A callable that creates the dependency
         """
         self._factories[name] = factory
-    
+
     def register_singleton(self, name: str, factory: callable) -> None:
         """
         Register a singleton factory that will create the instance only once.
-        
+
         Args:
             name: The name to register the singleton under
             factory: A callable that creates the singleton instance
@@ -55,56 +55,55 @@ class DependencyContainer:
         self._factories[name] = factory
         # Mark as singleton but don't create until requested
         self._singletons[name] = None
-    
+
     def get(self, name: str) -> Any:
         """
         Get a dependency by name.
-        
+
         Args:
             name: The name of the dependency to get
-            
+
         Returns:
             The dependency instance
-            
+
         Raises:
             KeyError: If the dependency is not registered
         """
         # Check for direct instance
         if name in self._dependencies:
             return self._dependencies[name]
-            
+
         # Check for singleton
         if name in self._singletons:
             # Create singleton if doesn't exist
             if self._singletons[name] is None:
                 self._singletons[name] = self._factories[name]()
             return self._singletons[name]
-            
+
         # Check for factory
         if name in self._factories:
             return self._factories[name]()
-            
+
         raise KeyError(f"Dependency '{name}' not registered")
-        
+
     def clear(self) -> None:
         """Clear all registered dependencies."""
         self._dependencies.clear()
         self._factories.clear()
         self._singletons.clear()
-        
+
     def has(self, name: str) -> bool:
         """
         Check if a dependency is registered.
-        
+
         Args:
             name: The name of the dependency
-            
+
         Returns:
             True if the dependency is registered, False otherwise
         """
-        return (name in self._dependencies or 
-                name in self._factories)
+        return name in self._dependencies or name in self._factories
 
 
 # Global dependency container instance
-container = DependencyContainer() 
+container = DependencyContainer()

mcp_proxy_adapter/commands/dependency_manager.py

@@ -19,12 +19,12 @@ class DependencyManager:
     """
     Manages plugin dependencies installation and verification.
     """
-    
+
     def __init__(self):
         """Initialize dependency manager."""
         self._installed_packages: Dict[str, str] = {}
         self._load_installed_packages()
-    
+
     def _load_installed_packages(self) -> None:
         """Load list of currently installed packages."""
         try:
@@ -33,39 +33,41 @@ class DependencyManager:
                 self._installed_packages[dist.project_name.lower()] = dist.version
         except Exception as e:
             logger.warning(f"Failed to load installed packages: {e}")
-    
-    def check_dependencies(self, dependencies: List[str]) -> Tuple[bool, List[str], List[str]]:
+
+    def check_dependencies(
+        self, dependencies: List[str]
+    ) -> Tuple[bool, List[str], List[str]]:
         """
         Check if dependencies are satisfied.
-        
+
         Args:
             dependencies: List of dependency names
-            
+
         Returns:
             Tuple of (all_satisfied, missing_deps, installed_deps)
         """
         if not dependencies:
             return True, [], []
-        
+
         missing_deps = []
         installed_deps = []
-        
+
         for dep in dependencies:
             if self._is_dependency_satisfied(dep):
                 installed_deps.append(dep)
             else:
                 missing_deps.append(dep)
-        
+
         all_satisfied = len(missing_deps) == 0
         return all_satisfied, missing_deps, installed_deps
-    
+
     def _is_dependency_satisfied(self, dependency: str) -> bool:
         """
         Check if a single dependency is satisfied.
-        
+
         Args:
             dependency: Dependency name or spec
-            
+
         Returns:
             True if dependency is satisfied, False otherwise
         """
@@ -75,38 +77,46 @@ class DependencyManager:
             return True
         except ImportError:
             pass
-        
+
         # Check if it's installed as a package
         try:
             pkg_resources.require(dependency)
             return True
         except (pkg_resources.DistributionNotFound, pkg_resources.VersionConflict):
             pass
-        
+
         # Check installed packages cache
-        dep_name = dependency.split('==')[0].split('>=')[0].split('<=')[0].split('!=')[0].split('~=')[0]
+        dep_name = (
+            dependency.split("==")[0]
+            .split(">=")[0]
+            .split("<=")[0]
+            .split("!=")[0]
+            .split("~=")[0]
+        )
         if dep_name.lower() in self._installed_packages:
             return True
-        
+
         return False
-    
-    def install_dependencies(self, dependencies: List[str], user_install: bool = False) -> Tuple[bool, List[str], List[str]]:
+
+    def install_dependencies(
+        self, dependencies: List[str], user_install: bool = False
+    ) -> Tuple[bool, List[str], List[str]]:
         """
         Install dependencies using pip.
-        
+
         Args:
             dependencies: List of dependency names to install
             user_install: Whether to install for current user only
-            
+
         Returns:
             Tuple of (success, installed_deps, failed_deps)
         """
         if not dependencies:
             return True, [], []
-        
+
         installed_deps = []
         failed_deps = []
-        
+
         for dep in dependencies:
             try:
                 if self._install_single_dependency(dep, user_install):
@@ -118,92 +128,91 @@ class DependencyManager:
             except Exception as e:
                 failed_deps.append(dep)
                 logger.error(f"Error installing dependency {dep}: {e}")
-        
+
         success = len(failed_deps) == 0
-        
+
         # Reload installed packages cache
         if success:
             self._load_installed_packages()
-        
+
         return success, installed_deps, failed_deps
-    
-    def _install_single_dependency(self, dependency: str, user_install: bool = False) -> bool:
+
+    def _install_single_dependency(
+        self, dependency: str, user_install: bool = False
+    ) -> bool:
         """
         Install a single dependency using pip.
-        
+
         Args:
             dependency: Dependency name or spec
             user_install: Whether to install for current user only
-            
+
         Returns:
             True if installation successful, False otherwise
         """
         try:
             # Build pip command
             cmd = [sys.executable, "-m", "pip", "install"]
-            
+
             if user_install:
                 cmd.append("--user")
-            
+
             # Add quiet flag to reduce output
             cmd.append("--quiet")
-            
+
             # Add dependency
             cmd.append(dependency)
-            
+
             logger.debug(f"Installing dependency: {' '.join(cmd)}")
-            
+
             # Run pip install
             result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                timeout=300  # 5 minutes timeout
+                cmd, capture_output=True, text=True, timeout=300  # 5 minutes timeout
             )
-            
+
             if result.returncode == 0:
                 logger.debug(f"Successfully installed {dependency}")
                 return True
             else:
                 logger.error(f"Failed to install {dependency}: {result.stderr}")
                 return False
-                
+
         except subprocess.TimeoutExpired:
             logger.error(f"Timeout while installing {dependency}")
             return False
         except Exception as e:
             logger.error(f"Error installing {dependency}: {e}")
             return False
-    
+
     def verify_installation(self, dependencies: List[str]) -> Tuple[bool, List[str]]:
         """
         Verify that dependencies are properly installed.
-        
+
         Args:
             dependencies: List of dependencies to verify
-            
+
         Returns:
             Tuple of (all_verified, failed_verifications)
         """
         if not dependencies:
             return True, []
-        
+
         failed_verifications = []
-        
+
         for dep in dependencies:
             if not self._is_dependency_satisfied(dep):
                 failed_verifications.append(dep)
-        
+
         all_verified = len(failed_verifications) == 0
         return all_verified, failed_verifications
-    
+
     def get_dependency_info(self, dependency: str) -> Dict[str, Any]:
         """
         Get information about a dependency.
-        
+
         Args:
             dependency: Dependency name
-            
+
         Returns:
             Dictionary with dependency information
         """
@@ -211,9 +220,9 @@ class DependencyManager:
             "name": dependency,
             "installed": False,
             "version": None,
-            "importable": False
+            "importable": False,
         }
-        
+
         # Check if it's installed
         try:
             dist = pkg_resources.get_distribution(dependency)
@@ -221,20 +230,20 @@ class DependencyManager:
             info["version"] = dist.version
         except pkg_resources.DistributionNotFound:
             pass
-        
+
         # Check if it's importable
         try:
             importlib.import_module(dependency)
             info["importable"] = True
         except ImportError:
             pass
-        
+
         return info
-    
+
     def list_installed_dependencies(self) -> Dict[str, str]:
         """
         Get list of all installed packages.
-        
+
         Returns:
             Dictionary mapping package names to versions
         """
@@ -242,4 +251,4 @@ class DependencyManager:
 
 
 # Global instance
-dependency_manager = DependencyManager() 
+dependency_manager = DependencyManager()

mcp_proxy_adapter/commands/echo_command.py

@@ -14,13 +14,13 @@ from mcp_proxy_adapter.commands.result import SuccessResult
 
 class EchoCommandResult(SuccessResult):
     """Result for echo command."""
-    
+
     def __init__(self, message: str, timestamp: Optional[str] = None):
         data = {"message": message}
         if timestamp:
             data["timestamp"] = timestamp
         super().__init__(data=data, message=message)
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """Get JSON schema for result."""
@@ -32,18 +32,18 @@ class EchoCommandResult(SuccessResult):
                     "type": "object",
                     "properties": {
                         "message": {"type": "string"},
-                        "timestamp": {"type": "string", "nullable": True}
-                    }
+                        "timestamp": {"type": "string", "nullable": True},
+                    },
                 },
-                "message": {"type": "string"}
+                "message": {"type": "string"},
             },
-            "required": ["success", "data"]
+            "required": ["success", "data"],
         }
 
 
 class EchoCommand(Command):
     """Echo command for testing purposes."""
-    
+
     name = "echo"
     version = "1.0.0"
     descr = "Echo command for testing"
@@ -51,17 +51,17 @@ class EchoCommand(Command):
     author = "Vasiliy Zdanovskiy"
     email = "vasilyvz@gmail.com"
     result_class = EchoCommandResult
-    
+
     async def execute(self, **kwargs) -> EchoCommandResult:
         """Execute echo command."""
         message = kwargs.get("message", "Hello, World!")
         timestamp = kwargs.get("timestamp")
-        
+
         # Simulate some processing time
         await asyncio.sleep(0.001)
-        
+
         return EchoCommandResult(message=message, timestamp=timestamp)
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """Get command schema."""
@@ -71,12 +71,12 @@ class EchoCommand(Command):
                 "message": {
                     "type": "string",
                     "description": "Message to echo",
-                    "default": "Hello, World!"
+                    "default": "Hello, World!",
                 },
                 "timestamp": {
                     "type": "string",
                     "description": "Optional timestamp",
-                    "nullable": True
-                }
-            }
+                    "nullable": True,
+                },
+            },
         }