mcp-proxy-adapter 2.0.1__py3-none-any.whl → 6.9.50__py3-none-any.whl

analyzers/type_analyzer.py

@@ -1,151 +0,0 @@
-"""
-Type analyzer for extracting information from function type annotations.
-"""
-import inspect
-from typing import Dict, Any, List, Optional, Callable, Union, get_origin, get_args, get_type_hints
-
-class TypeAnalyzer:
-    """
-    Type analyzer for extracting information from function type annotations.
-    
-    This class is responsible for analyzing type annotations of command handler functions
-    and converting them to JSON Schema/OpenAPI type format.
-    """
-    
-    def __init__(self):
-        # Mapping Python types to OpenAPI types
-        self.type_map = {
-            str: "string",
-            int: "integer",
-            float: "number",
-            bool: "boolean",
-            list: "array",
-            dict: "object",
-            Any: "object",
-            None: "null",
-        }
-    
-    def analyze(self, handler: Callable) -> Dict[str, Any]:
-        """
-        Analyzes function type annotations and returns metadata.
-        
-        Args:
-            handler: Handler function to analyze
-            
-        Returns:
-            Dict[str, Any]: Metadata about parameter types and return value
-        """
-        result = {
-            "parameters": {},
-            "returns": None
-        }
-        
-        # Get function signature
-        sig = inspect.signature(handler)
-        
-        # Get type annotations
-        type_hints = self._get_type_hints(handler)
-        
-        # Analyze parameters
-        for param_name, param in sig.parameters.items():
-            # Skip self for methods
-            if param_name == 'self':
-                continue
-                
-            # If parameter is named params, assume it's a dictionary of all parameters
-            if param_name == 'params':
-                continue
-                
-            # Determine if parameter is required
-            required = param.default == inspect.Parameter.empty
-            
-            # Determine parameter type
-            param_type = "object"  # Default type
-            
-            if param_name in type_hints:
-                param_type = self._map_type_to_openapi(type_hints[param_name])
-                
-            # Create parameter metadata
-            param_metadata = {
-                "type": param_type,
-                "required": required
-            }
-            
-            # Add default value if exists
-            if param.default != inspect.Parameter.empty:
-                # Some default values cannot be serialized to JSON
-                # So we convert them to string representation for such cases
-                if param.default is None or isinstance(param.default, (str, int, float, bool, list, dict)):
-                    param_metadata["default"] = param.default
-            
-            # Add parameter to metadata
-            result["parameters"][param_name] = param_metadata
-        
-        # Analyze return value
-        if 'return' in type_hints:
-            result["returns"] = self._map_type_to_openapi(type_hints['return'])
-        
-        return result
-    
-    def _get_type_hints(self, handler: Callable) -> Dict[str, Any]:
-        """
-        Gets type annotations of a function.
-        
-        Args:
-            handler: Handler function
-            
-        Returns:
-            Dict[str, Any]: Type annotations
-        """
-        try:
-            return get_type_hints(handler)
-        except Exception:
-            # If failed to get annotations via get_type_hints,
-            # extract them manually from __annotations__
-            return getattr(handler, "__annotations__", {})
-    
-    def _map_type_to_openapi(self, type_hint: Any) -> Union[str, Dict[str, Any]]:
-        """
-        Converts Python type to OpenAPI type.
-        
-        Args:
-            type_hint: Python type
-            
-        Returns:
-            Union[str, Dict[str, Any]]: OpenAPI type string representation or schema
-        """
-        # Check for None
-        if type_hint is None:
-            return "null"
-        
-        # Handle primitive types
-        if type_hint in self.type_map:
-            return self.type_map[type_hint]
-        
-        # Check for generic types
-        origin = get_origin(type_hint)
-        if origin is not None:
-            # Handle List[X], Dict[X, Y], etc.
-            if origin in (list, List):
-                args = get_args(type_hint)
-                if args:
-                    item_type = self._map_type_to_openapi(args[0])
-                    return {
-                        "type": "array",
-                        "items": item_type if isinstance(item_type, dict) else {"type": item_type}
-                    }
-                return "array"
-            elif origin in (dict, Dict):
-                # For dict we just return object, as OpenAPI
-                # doesn't have a direct equivalent for Dict[X, Y]
-                return "object"
-            elif origin is Union:
-                # For Union we take the first type that is not None
-                args = get_args(type_hint)
-                for arg in args:
-                    if arg is not type(None):
-                        return self._map_type_to_openapi(arg)
-                return "object"
-        
-        # Default to object
-        return "object" 

cli/__init__.py

@@ -1,12 +0,0 @@
-"""
-Командный интерфейс для запуска команд из командной строки.
-
-Этот модуль предоставляет инструменты для создания командной строки
-на основе зарегистрированных команд.
-"""
-
-from command_registry.cli.command_runner import CommandRunner
-
-__all__ = [
-    'CommandRunner',
-] 

cli/__main__.py

@@ -1,79 +0,0 @@
-#!/usr/bin/env python
-"""
-Entry point for the command registry CLI interface.
-
-This module allows running commands from the command line
-using the command dispatcher.
-
-Usage:
-    python -m command_registry.cli [command] [args...]
-"""
-
-import os
-import sys
-import importlib.util
-from typing import Optional
-
-from command_registry.cli.command_runner import CommandRunner
-from command_registry.dispatchers.base_dispatcher import BaseDispatcher
-from command_registry.dispatchers.command_dispatcher import CommandDispatcher
-
-
-def find_dispatcher() -> BaseDispatcher:
-    """
-    Finds and creates command dispatcher.
-    
-    Search order:
-    1. Checks DISPATCHER_MODULE environment variable
-    2. Looks for app.py in current directory
-    3. Creates new CommandDispatcher
-    
-    Returns:
-        BaseDispatcher: Command dispatcher
-    """
-    # Check environment variable
-    dispatcher_module = os.environ.get("DISPATCHER_MODULE")
-    if dispatcher_module:
-        try:
-            module_path, attr_name = dispatcher_module.rsplit(":", 1)
-            module = importlib.import_module(module_path)
-            return getattr(module, attr_name)
-        except (ValueError, ImportError, AttributeError) as e:
-            print(f"Failed to load dispatcher from {dispatcher_module}: {e}", 
-                  file=sys.stderr)
-    
-    # Check app.py file
-    app_path = os.path.join(os.getcwd(), "app.py")
-    if os.path.exists(app_path):
-        try:
-            spec = importlib.util.spec_from_file_location("app", app_path)
-            if spec and spec.loader:
-                app = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(app)
-                
-                # Look for dispatcher in module
-                dispatcher = getattr(app, "dispatcher", None)
-                if dispatcher and isinstance(dispatcher, BaseDispatcher):
-                    return dispatcher
-        except Exception as e:
-            print(f"Failed to load dispatcher from app.py: {e}", 
-                  file=sys.stderr)
-    
-    # Create new dispatcher if not found
-    return CommandDispatcher()
-
-
-def main() -> None:
-    """
-    Main function for running CLI interface.
-    """
-    # Get dispatcher
-    dispatcher = find_dispatcher()
-    
-    # Create and run CommandRunner
-    runner = CommandRunner(dispatcher)
-    runner.run(sys.argv[1:])
-
-
-if __name__ == "__main__":
-    main() 

cli/command_runner.py

@@ -1,233 +0,0 @@
-"""
-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

@@ -1,14 +0,0 @@
-"""
-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

@@ -1,85 +0,0 @@
-"""
-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