mcp-proxy-adapter 1.0.0__py3-none-any.whl

cli/command_runner.py

@@ -0,0 +1,233 @@
+"""
+Command line utility for executing commands.
+
+Provides a command line interface for the command dispatcher,
+allowing execution of registered commands and getting help information.
+"""
+
+import argparse
+import json
+import sys
+from typing import Any, Dict, List, Optional, Sequence
+
+from command_registry.dispatchers.base_dispatcher import BaseDispatcher
+
+
+class CommandRunner:
+    """
+    Command line utility for executing commands.
+    
+    Converts command line arguments into dispatcher command calls.
+    Provides ability to get help information about commands.
+    """
+    
+    def __init__(self, dispatcher: BaseDispatcher):
+        """
+        Initializes CommandRunner.
+        
+        Args:
+            dispatcher: Command dispatcher for executing commands
+        """
+        self.dispatcher = dispatcher
+    
+    def build_parser(self) -> argparse.ArgumentParser:
+        """
+        Creates argument parser based on registered commands.
+        
+        Returns:
+            Command line argument parser
+        """
+        parser = argparse.ArgumentParser(
+            description="Execute commands from command registry",
+            add_help=False,  # Disable standard help
+        )
+        
+        # Add main arguments
+        parser.add_argument(
+            "command", 
+            help="Command name to execute or 'help' to get list of commands",
+            nargs="?",
+            default="help",
+        )
+        
+        parser.add_argument(
+            "--help", "-h", 
+            action="store_true",
+            help="Show help for specified command",
+            dest="show_help",
+        )
+        
+        parser.add_argument(
+            "--json", 
+            action="store_true",
+            help="Output result in JSON format",
+        )
+        
+        return parser
+    
+    def _handle_help_command(self, args: Optional[List[str]] = None) -> None:
+        """
+        Outputs help information about available commands.
+        
+        Args:
+            args: List of arguments, if first argument is command name,
+                 outputs help for that command
+        """
+        if args and len(args) > 0 and args[0] != "help":
+            # Help for specific command
+            command_name = args[0]
+            if command_name not in self.dispatcher.get_valid_commands():
+                print(f"Unknown command: {command_name}", file=sys.stderr)
+                return
+            
+            info = self.dispatcher.get_command_info(command_name)
+            
+            print(f"\nCommand: {command_name}\n")
+            
+            if info.get("description"):
+                print(f"Description: {info['description']}\n")
+            
+            if "parameters" in info and info["parameters"]:
+                print("Parameters:")
+                for name, param_info in info["parameters"].items():
+                    param_type = param_info.get("type", "any")
+                    required = param_info.get("required", False)
+                    description = param_info.get("description", "")
+                    
+                    req_str = " (required)" if required else ""
+                    print(f"  {name} ({param_type}){req_str}")
+                    if description:
+                        print(f"    {description}")
+                print()
+            
+            if "returns" in info and info["returns"]:
+                print(f"Returns: {info['returns']}")
+            
+            print("\nUsage:")
+            params_str = " ".join(
+                f"--{name}=<value>" for name in info.get("parameters", {})
+            )
+            print(f"  python -m command_registry.cli {command_name} {params_str}")
+        else:
+            # General help
+            commands = self.dispatcher.get_commands_info()
+            
+            print("\nAvailable commands:\n")
+            for name, info in commands.items():
+                description = info.get("description", "No description")
+                # Show only first line of description for brevity
+                short_desc = description.split("\n")[0]
+                print(f"  {name:<20} {short_desc}")
+            
+            print("\nTo get detailed information about a command use:")
+            print("  python -m command_registry.cli help <command>")
+            print("  python -m command_registry.cli <command> --help")
+    
+    def run(self, args: Sequence[str]) -> None:
+        """
+        Runs command based on provided arguments.
+        
+        Args:
+            args: Command line arguments (without program name)
+        """
+        parser = self.build_parser()
+        
+        # Parse arguments
+        parsed_args, remaining = parser.parse_known_args(args)
+        
+        # Handle help command or --help flag
+        if parsed_args.command == "help" or parsed_args.show_help:
+            if parsed_args.command == "help":
+                self._handle_help_command(remaining)
+            else:
+                self._handle_help_command([parsed_args.command])
+            return
+        
+        # Check command existence
+        if parsed_args.command not in self.dispatcher.get_valid_commands():
+            print(f"Unknown command: {parsed_args.command}", file=sys.stderr)
+            print("Use 'help' to get list of available commands", file=sys.stderr)
+            sys.exit(1)
+        
+        # Convert remaining arguments to command parameters
+        command_params = {}
+        command_info = self.dispatcher.get_command_info(parsed_args.command)
+        expected_params = command_info.get("parameters", {})
+        
+        # Parse parameters from remaining arguments
+        i = 0
+        while i < len(remaining):
+            arg = remaining[i]
+            
+            # Support --param=value format
+            if arg.startswith("--") and "=" in arg:
+                param_name, value = arg[2:].split("=", 1)
+                command_params[param_name] = self._parse_value(value)
+                i += 1
+            # Support --param value format
+            elif arg.startswith("--"):
+                param_name = arg[2:]
+                if i + 1 < len(remaining) and not remaining[i + 1].startswith("--"):
+                    command_params[param_name] = self._parse_value(remaining[i + 1])
+                    i += 2
+                else:
+                    # Boolean flag
+                    command_params[param_name] = True
+                    i += 1
+            else:
+                print(f"Unknown argument: {arg}", file=sys.stderr)
+                i += 1
+        
+        # Check required parameters
+        for param_name, param_info in expected_params.items():
+            if param_info.get("required", False) and param_name not in command_params:
+                print(f"Missing required parameter: {param_name}", file=sys.stderr)
+                sys.exit(1)
+        
+        try:
+            # Execute command
+            result = self.dispatcher.execute(parsed_args.command, **command_params)
+            
+            # Output result
+            if parsed_args.json:
+                print(json.dumps(result, ensure_ascii=False, indent=2))
+            elif result is not None:
+                print(result)
+        except Exception as e:
+            print(f"Error executing command: {e}", file=sys.stderr)
+            sys.exit(1)
+    
+    def _parse_value(self, value_str: str) -> Any:
+        """
+        Parses string value into corresponding type.
+        
+        Args:
+            value_str: String representation of value
+            
+        Returns:
+            Parsed value of corresponding type
+        """
+        # Boolean values
+        if value_str.lower() in ("true", "yes", "y", "1"):
+            return True
+        if value_str.lower() in ("false", "no", "n", "0"):
+            return False
+        
+        # Numbers
+        try:
+            if "." in value_str:
+                return float(value_str)
+            return int(value_str)
+        except ValueError:
+            pass
+        
+        # JSON
+        if (value_str.startswith("{") and value_str.endswith("}")) or \
+           (value_str.startswith("[") and value_str.endswith("]")):
+            try:
+                return json.loads(value_str)
+            except json.JSONDecodeError:
+                pass
+        
+        # Default - string
+        return value_str 

dispatchers/__init__.py

@@ -0,0 +1,14 @@
+"""
+Command dispatchers for registering and executing commands.
+
+This module contains base classes and implementations of command dispatchers
+that are responsible for registering and executing commands.
+"""
+
+from .base_dispatcher import BaseDispatcher
+from .json_rpc_dispatcher import JsonRpcDispatcher
+
+__all__ = [
+    'BaseDispatcher',
+    'JsonRpcDispatcher',
+] 

dispatchers/base_dispatcher.py

@@ -0,0 +1,85 @@
+"""
+Base command dispatcher class.
+"""
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Callable, List, Optional
+
+class BaseDispatcher(ABC):
+    """
+    Abstract base class for command dispatchers.
+    
+    Defines the interface that all command dispatchers must implement.
+    Dispatchers are responsible for registering and executing commands.
+    """
+    
+    @abstractmethod
+    def register_handler(
+        self, 
+        command: str, 
+        handler: Callable, 
+        description: str = "", 
+        summary: str = "", 
+        params: Dict[str, Any] = None
+    ) -> None:
+        """
+        Registers a command handler.
+        
+        Args:
+            command: Command name
+            handler: Command handler function
+            description: Command description
+            summary: Brief command summary
+            params: Command parameters description
+        """
+        pass
+    
+    @abstractmethod
+    def execute(self, command: str, **kwargs) -> Any:
+        """
+        Executes a command with the specified parameters.
+        
+        Args:
+            command: Command name
+            **kwargs: Command parameters
+            
+        Returns:
+            Any: Command execution result
+            
+        Raises:
+            CommandNotFoundError: If command is not found
+            CommandExecutionError: On command execution error
+        """
+        pass
+    
+    @abstractmethod
+    def get_valid_commands(self) -> List[str]:
+        """
+        Returns a list of all registered command names.
+        
+        Returns:
+            List[str]: List of command names
+        """
+        pass
+    
+    @abstractmethod
+    def get_command_info(self, command: str) -> Optional[Dict[str, Any]]:
+        """
+        Returns information about a command.
+        
+        Args:
+            command: Command name
+            
+        Returns:
+            Optional[Dict[str, Any]]: Command information or None if command not found
+        """
+        pass
+    
+    @abstractmethod
+    def get_commands_info(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Returns information about all registered commands.
+        
+        Returns:
+            Dict[str, Dict[str, Any]]: Dictionary {command_name: information}
+        """
+        pass 

dispatchers/json_rpc_dispatcher.py

@@ -0,0 +1,198 @@
+"""
+Implementation of a JSON-RPC based command dispatcher.
+"""
+from typing import Dict, Any, Callable, List, Optional, Union
+import inspect
+import logging
+import traceback
+from .base_dispatcher import BaseDispatcher
+
+logger = logging.getLogger("command_registry")
+
+class CommandError(Exception):
+    """Base class for command errors"""
+    pass
+
+class CommandNotFoundError(CommandError):
+    """Error raised when attempting to execute a non-existent command"""
+    pass
+
+class CommandExecutionError(CommandError):
+    """Error raised during command execution"""
+    pass
+
+class JsonRpcDispatcher(BaseDispatcher):
+    """
+    JSON-RPC based command dispatcher.
+    
+    Implements the BaseDispatcher interface for handling commands in JSON-RPC 2.0 format.
+    Supports registration, execution, and retrieval of command information.
+    """
+    
+    def __init__(self):
+        """Initializes a new dispatcher instance"""
+        self._handlers = {}
+        self._metadata = {}
+        
+        # Register the built-in help command
+        self.register_handler(
+            command="help",
+            handler=self._help_command,
+            description="Returns information about available commands",
+            summary="Command help",
+            params={
+                "command": {
+                    "type": "string",
+                    "description": "Command name for detailed information",
+                    "required": False
+                }
+            }
+        )
+    
+    def register_handler(
+        self, 
+        command: str, 
+        handler: Callable, 
+        description: str = "", 
+        summary: str = "", 
+        params: Dict[str, Any] = None
+    ) -> None:
+        """
+        Registers a command handler.
+        
+        Args:
+            command: Command name
+            handler: Command handler function
+            description: Command description
+            summary: Brief command summary
+            params: Command parameters description
+        """
+        if not params:
+            params = {}
+            
+        # Save the handler
+        self._handlers[command] = handler
+        
+        # Save metadata
+        self._metadata[command] = {
+            "description": description,
+            "summary": summary or command.replace("_", " ").title(),
+            "params": params
+        }
+        
+        logger.debug(f"Registered command: {command}")
+    
+    def execute(self, command: str, **kwargs) -> Any:
+        """
+        Executes a command with the specified parameters.
+        
+        Args:
+            command: Command name
+            **kwargs: Command parameters
+            
+        Returns:
+            Any: Command execution result
+            
+        Raises:
+            CommandNotFoundError: If command is not found
+            CommandExecutionError: On command execution error
+        """
+        # Check if command exists
+        if command not in self._handlers:
+            raise CommandNotFoundError(f"Command '{command}' not found")
+        
+        handler = self._handlers[command]
+        
+        try:
+            # Get function signature
+            sig = inspect.signature(handler)
+            
+            # If function accepts params dictionary, pass all parameters in it
+            if len(sig.parameters) == 1 and list(sig.parameters.keys())[0] == 'params':
+                return handler(params=kwargs)
+            
+            # Otherwise pass parameters as named arguments
+            return handler(**kwargs)
+        except Exception as e:
+            # Log the error
+            logger.error(f"Error executing command '{command}': {str(e)}")
+            logger.debug(traceback.format_exc())
+            
+            # Re-raise the exception
+            raise CommandExecutionError(f"Error executing command '{command}': {str(e)}")
+    
+    def get_valid_commands(self) -> List[str]:
+        """
+        Returns a list of all registered command names.
+        
+        Returns:
+            List[str]: List of command names
+        """
+        return list(self._handlers.keys())
+    
+    def get_command_info(self, command: str) -> Optional[Dict[str, Any]]:
+        """
+        Returns information about a command.
+        
+        Args:
+            command: Command name
+            
+        Returns:
+            Optional[Dict[str, Any]]: Command information or None if command not found
+        """
+        if command not in self._metadata:
+            return None
+        
+        return self._metadata[command]
+    
+    def get_commands_info(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Returns information about all registered commands.
+        
+        Returns:
+            Dict[str, Dict[str, Any]]: Dictionary {command_name: information}
+        """
+        return self._metadata.copy()
+    
+    def _help_command(self, params: Dict[str, Any] = None) -> Dict[str, Any]:
+        """
+        Built-in help command for getting command information.
+        
+        Args:
+            params: Command parameters
+                command: Command name for detailed information
+                
+        Returns:
+            Dict[str, Any]: Command help information
+        """
+        if not params:
+            params = {}
+            
+        # If specific command is specified, return information only about it
+        if "command" in params and params["command"]:
+            command = params["command"]
+            if command not in self._metadata:
+                return {
+                    "error": f"Command '{command}' not found",
+                    "available_commands": list(self._metadata.keys())
+                }
+            
+            return {
+                "command": command,
+                "info": self._metadata[command]
+            }
+        
+        # Otherwise return brief information about all commands
+        commands_info = {}
+        for cmd, info in self._metadata.items():
+            commands_info[cmd] = {
+                "summary": info["summary"],
+                "description": info["description"],
+                "params_count": len(info["params"])
+            }
+        
+        return {
+            "commands": commands_info,
+            "total": len(commands_info),
+            "note": "Use the 'command' parameter to get detailed information about a specific command"
+        } 

generators/__init__.py

@@ -0,0 +1,14 @@
+"""
+Генераторы API на основе команд и их метаданных.
+
+Этот модуль содержит классы для автоматической генерации API интерфейсов
+(REST, OpenAPI и др.) на основе зарегистрированных команд.
+"""
+
+from command_registry.generators.rest_api_generator import RestApiGenerator
+from command_registry.generators.openapi_generator import OpenApiGenerator
+
+__all__ = [
+    'RestApiGenerator',
+    'OpenApiGenerator',
+]