mcp-proxy-adapter 6.9.28__py3-none-any.whl → 6.9.30__py3-none-any.whl

mcp_proxy_adapter/commands/config_command.py

@@ -100,31 +100,3 @@ class ConfigCommand(Command):
         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.
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "operation": {
-                    "type": "string",
-                    "enum": ["get", "set"],
-                    "default": "get",
-                    "description": "Operation to perform (get or set)",
-                },
-                "path": {
-                    "type": "string",
-                    "description": "Configuration path in dot notation "
-                    "(e.g. 'server.host')",
-                },
-                "value": {
-                    "description": "Value to set (required for " "'set' operation)"
-                },
-            },
-            "required": ["operation"],
-            "additionalProperties": False,
-        }

mcp_proxy_adapter/commands/dependency_container.py

@@ -5,7 +5,7 @@ This module provides a container for registering and resolving dependencies
 for command instances in the microservice.
 """
 
-from typing import Any, Dict, Optional, Type, TypeVar, cast
+from typing import TypeVar, Dict, Any, Callable, Optional
 
 T = TypeVar("T")
 
@@ -24,67 +24,9 @@ class DependencyContainer:
         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
-        """
-        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."""
@@ -92,17 +34,6 @@ class DependencyContainer:
         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
 
 
 # Global dependency container instance

mcp_proxy_adapter/commands/dependency_manager.py

@@ -12,7 +12,6 @@ import subprocess
 import sys
 import importlib
 from typing import List, Dict, Any, Tuple
-from pathlib import Path
 
 try:  # Python 3.8+
     from importlib import metadata as importlib_metadata  # type: ignore
@@ -20,7 +19,6 @@ except Exception:  # pragma: no cover - very old Python fallback
     import importlib_metadata  # type: ignore
 
 from packaging.requirements import Requirement
-from packaging.specifiers import SpecifierSet
 from packaging.version import Version, InvalidVersion
 
 from mcp_proxy_adapter.core.logging import get_global_logger
@@ -51,32 +49,6 @@ class DependencyManager:
         except Exception as e:
             get_global_logger().warning(f"Failed to load installed packages: {e}")
 
-    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:
         """
@@ -115,44 +87,6 @@ class DependencyManager:
             # If version parsing fails, fallback to string comparison via specifier
             return req.specifier.contains(installed_version, prereleases=True)
 
-    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):
-                    installed_deps.append(dep)
-                    get_global_logger().info(f"Successfully installed dependency: {dep}")
-                else:
-                    failed_deps.append(dep)
-                    get_global_logger().error(f"Failed to install dependency: {dep}")
-            except Exception as e:
-                failed_deps.append(dep)
-                get_global_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
@@ -201,70 +135,8 @@ class DependencyManager:
             get_global_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
-        """
-        info: Dict[str, Any] = {
-            "name": dependency,
-            "installed": False,
-            "version": None,
-            "importable": False,
-        }
-
-        # Check if it's installed
-        try:
-            version = importlib_metadata.version(dependency)
-            info["installed"] = True
-            info["version"] = version
-        except importlib_metadata.PackageNotFoundError:
-            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
-        """
-        return self._installed_packages.copy()
 
 
 # Global instance

mcp_proxy_adapter/commands/echo_command.py

@@ -22,23 +22,6 @@ class EchoCommandResult(SuccessResult):
         super().__init__(data=data, message=message)
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Get JSON schema for result."""
-        return {
-            "type": "object",
-            "properties": {
-                "success": {"type": "boolean"},
-                "data": {
-                    "type": "object",
-                    "properties": {
-                        "message": {"type": "string"},
-                        "timestamp": {"type": "string", "nullable": True},
-                    },
-                },
-                "message": {"type": "string"},
-            },
-            "required": ["success", "data"],
-        }
 
 
 class EchoCommand(Command):
@@ -63,20 +46,3 @@ class EchoCommand(Command):
         return EchoCommandResult(message=message, timestamp=timestamp)
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Get command schema."""
-        return {
-            "type": "object",
-            "properties": {
-                "message": {
-                    "type": "string",
-                    "description": "Message to echo",
-                    "default": "Hello, World!",
-                },
-                "timestamp": {
-                    "type": "string",
-                    "description": "Optional timestamp",
-                    "nullable": True,
-                },
-            },
-        }

mcp_proxy_adapter/commands/health_command.py

@@ -7,10 +7,8 @@ import platform
 import sys
 import psutil
 from datetime import datetime
-from typing import Dict, Any, Optional
 
 from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult
 from mcp_proxy_adapter.commands.command_registry import registry
 from mcp_proxy_adapter.core.proxy_registration import get_proxy_registration_status
 
@@ -91,7 +89,6 @@ class HealthCommand(Command):
         """
         # Get version from package
         try:
-            from mcp_proxy_adapter.version import __version__ as version
         except ImportError:
             version = "unknown"
 

mcp_proxy_adapter/commands/help_command.py

@@ -39,150 +39,8 @@ class HelpResult(CommandResult):
         self.commands_info = commands_info
         self.command_info = command_info
 
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert result to dictionary.
-
-        Returns:
-            Dict[str, Any]: Result as dictionary
-        """
-        try:
-            get_global_logger().debug(
-                f"HelpResult.to_dict: command_info={self.command_info is not None}, commands_info={self.commands_info is not None}"
-            )
-
-            # Защита от None для self.command_info
-            if self.command_info is not None:
-                get_global_logger().debug(
-                    f"HelpResult.to_dict: returning command_info for {self.command_info.get('name', 'unknown')}"
-                )
-                # Делаем безопасное получение всех полей с дефолтными значениями
-                metadata = self.command_info.get("metadata", {})
-                schema = self.command_info.get("schema", {})
-                return {
-                    "cmdname": self.command_info.get("name", "unknown"),
-                    "info": {
-                        "description": metadata.get("description", ""),
-                        "summary": metadata.get("summary", ""),
-                        "params": schema.get("properties", {}),
-                        "examples": metadata.get("examples", []),
-                    },
-                }
-
-            # Защита от None для self.commands_info
-            if self.commands_info is None:
-                get_global_logger().warning(
-                    "HelpResult.to_dict: commands_info is None, создаем пустой результат"
-                )
-                # Возвращаем пустой список команд вместо ошибки
-                return {
-                    "tool_info": {
-                        "name": "MCP-Proxy API Service",
-                        "description": "JSON-RPC API for microservice command execution",
-                        "version": "1.0.0",
-                    },
-                    "help_usage": {
-                        "description": "Get information about commands",
-                        "examples": [
-                            {
-                                "command": "help",
-                                "description": "List of all available commands",
-                            },
-                            {
-                                "command": "help",
-                                "params": {"cmdname": "command_name"},
-                                "description": "Get detailed information about a specific command",
-                            },
-                        ],
-                    },
-                    "commands": {},
-                    "total": 0,
-                    "note": 'To get detailed information about a specific command, call help with parameter: POST /cmd {"command": "help", "params": {"cmdname": "<command_name>"}}',
-                }
-
-            # For list of all commands, return as is (already formatted)
-            get_global_logger().debug(
-                f"HelpResult.to_dict: processing commands_info with {len(self.commands_info.get('commands', {}))} commands"
-            )
-            result = self.commands_info.copy()
-
-            # Add total count and note about usage
-            commands = result.get("commands", {})
-            result["total"] = len(commands)
-            result["note"] = (
-                'To get detailed information about a specific command, call help with parameter: POST /cmd {"command": "help", "params": {"cmdname": "<command_name>"}}'
-            )
-
-            get_global_logger().debug(
-                f"HelpResult.to_dict: returning result with {result['total']} commands"
-            )
-            return result
-        except Exception as e:
-            get_global_logger().error(f"Ошибка в HelpResult.to_dict: {e}")
-            get_global_logger().debug(f"Трассировка: {traceback.format_exc()}")
-            # В случае неожиданной ошибки возвращаем базовый ответ вместо ошибки
-            return {
-                "tool_info": {
-                    "name": "MCP-Proxy API Service",
-                    "description": "JSON-RPC API for microservice command execution",
-                    "version": "1.0.0",
-                },
-                "commands": {},
-                "total": 0,
-                "error": str(e),
-            }
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for result validation.
-
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
-        return {
-            "type": "object",
-            "oneOf": [
-                {
-                    "properties": {
-                        "commands": {
-                            "type": "object",
-                            "additionalProperties": {
-                                "type": "object",
-                                "properties": {"description": {"type": "string"}},
-                            },
-                        },
-                        "tool_info": {
-                            "type": "object",
-                            "properties": {
-                                "name": {"type": "string"},
-                                "description": {"type": "string"},
-                                "version": {"type": "string"},
-                            },
-                        },
-                        "help_usage": {"type": "object"},
-                        "total": {"type": "integer"},
-                        "note": {"type": "string"},
-                    },
-                    "required": ["commands"],
-                },
-                {
-                    "properties": {
-                        "cmdname": {"type": "string"},
-                        "info": {
-                            "type": "object",
-                            "properties": {
-                                "description": {"type": "string"},
-                                "summary": {"type": "string"},
-                                "params": {"type": "object"},
-                                "examples": {"type": "array"},
-                            },
-                        },
-                    },
-                    "required": ["cmdname", "info"],
-                },
-            ],
-        }
 
 
 class HelpCommand(Command):
@@ -315,20 +173,3 @@ class HelpCommand(Command):
             )
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for command parameters validation.
-
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "cmdname": {
-                    "type": "string",
-                    "description": "Name of command to get information about",
-                }
-            },
-            "additionalProperties": False,
-        }

mcp_proxy_adapter/commands/hooks.py

@@ -5,7 +5,6 @@ This module provides a hook system for registering custom commands
 that will be called during system initialization.
 """
 
-from typing import Callable, List, Optional, Dict, Any, Union
 from enum import Enum
 from dataclasses import dataclass
 from mcp_proxy_adapter.core.logging import get_global_logger
@@ -109,147 +108,11 @@ class CommandHooks:
         self._after_command_hooks.append(hook_func)
         get_global_logger().debug(f"Registered after command hook: {hook_func.__name__}")
 
-    def execute_custom_commands_hooks(self, registry) -> int:
-        """
-        Execute all registered custom commands hooks.
-
-        Args:
-            registry: Command registry instance.
-
-        Returns:
-            Number of hooks executed.
-        """
-        get_global_logger().debug("Executing custom commands hooks...")
-        hooks_executed = 0
-
-        for hook_func in self._custom_commands_hooks:
-            try:
-                hook_func(registry)
-                hooks_executed += 1
-                get_global_logger().debug(f"Executed custom commands hook: {hook_func.__name__}")
-            except Exception as e:
-                get_global_logger().error(
-                    f"Failed to execute custom commands hook {hook_func.__name__}: {e}"
-                )
-
-        get_global_logger().info(f"Executed {hooks_executed} custom commands hooks")
-        return hooks_executed
-
-    def execute_before_init_hooks(self) -> int:
-        """
-        Execute all registered before initialization hooks.
-
-        Returns:
-            Number of hooks executed.
-        """
-        get_global_logger().debug("Executing before init hooks...")
-        hooks_executed = 0
-
-        for hook_func in self._before_init_hooks:
-            try:
-                hook_func()
-                hooks_executed += 1
-                get_global_logger().debug(f"Executed before init hook: {hook_func.__name__}")
-            except Exception as e:
-                get_global_logger().error(
-                    f"Failed to execute before init hook {hook_func.__name__}: {e}"
-                )
-
-        get_global_logger().debug(f"Executed {hooks_executed} before init hooks")
-        return hooks_executed
-
-    def execute_after_init_hooks(self) -> int:
-        """
-        Execute all registered after initialization hooks.
 
-        Returns:
-            Number of hooks executed.
-        """
-        get_global_logger().debug("Executing after init hooks...")
-        hooks_executed = 0
-
-        for hook_func in self._after_init_hooks:
-            try:
-                hook_func()
-                hooks_executed += 1
-                get_global_logger().debug(f"Executed after init hook: {hook_func.__name__}")
-            except Exception as e:
-                get_global_logger().error(
-                    f"Failed to execute after init hook {hook_func.__name__}: {e}"
-                )
-
-        get_global_logger().debug(f"Executed {hooks_executed} after init hooks")
-        return hooks_executed
-
-    def execute_before_command_hooks(
-        self, command_name: str, params: Dict[str, Any]
-    ) -> int:
-        """
-        Execute all registered before command execution hooks.
 
-        Args:
-            command_name: Name of the command being executed
-            params: Command parameters
 
-        Returns:
-            Number of hooks executed.
-        """
-        get_global_logger().debug(f"Executing before command hooks for: {command_name}")
-        hooks_executed = 0
-
-        for hook_func in self._before_command_hooks:
-            try:
-                hook_func(command_name, params)
-                hooks_executed += 1
-                get_global_logger().debug(f"Executed before command hook: {hook_func.__name__}")
-            except Exception as e:
-                get_global_logger().error(
-                    f"Failed to execute before command hook {hook_func.__name__}: {e}"
-                )
-
-        get_global_logger().debug(f"Executed {hooks_executed} before command hooks")
-        return hooks_executed
-
-    def execute_after_command_hooks(
-        self, command_name: str, params: Dict[str, Any], result: Any
-    ) -> int:
-        """
-        Execute all registered after command execution hooks.
 
-        Args:
-            command_name: Name of the command that was executed
-            params: Command parameters that were used
-            result: Command execution result
 
-        Returns:
-            Number of hooks executed.
-        """
-        get_global_logger().debug(f"Executing after command hooks for: {command_name}")
-        hooks_executed = 0
-
-        for hook_func in self._after_command_hooks:
-            try:
-                hook_func(command_name, params, result)
-                hooks_executed += 1
-                get_global_logger().debug(f"Executed after command hook: {hook_func.__name__}")
-            except Exception as e:
-                get_global_logger().error(
-                    f"Failed to execute after command hook {hook_func.__name__}: {e}"
-                )
-
-        get_global_logger().debug(f"Executed {hooks_executed} after command hooks")
-        return hooks_executed
-
-    def clear_hooks(self) -> None:
-        """
-        Clear all registered hooks.
-        """
-        self._custom_commands_hooks.clear()
-        self._before_init_hooks.clear()
-        self._after_init_hooks.clear()
-        self._before_command_hooks.clear()
-        self._after_command_hooks.clear()
-        get_global_logger().debug("Cleared all hooks")
 
 
 # Global hooks instance