mcp-proxy-adapter 2.1.0__py3-none-any.whl → 2.1.2__py3-none-any.whl

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 

generators/__init__.py

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

generators/endpoint_generator.py

@@ -1,172 +0,0 @@
-"""
-REST API endpoint generator based on registered commands.
-"""
-from typing import Any, Callable, Dict, List, Optional
-import inspect
-import asyncio
-from fastapi import APIRouter, Depends, Request, HTTPException
-from pydantic import BaseModel, create_model
-
-class EndpointGenerator:
-    """
-    REST API endpoint generator based on registered commands.
-    
-    Creates dynamic FastAPI endpoints by automatically generating
-    request and response models based on signatures and docstrings
-    of registered handler functions.
-    """
-    
-    def __init__(self, router: APIRouter, dispatcher: Any):
-        """
-        Initialize endpoint generator.
-        
-        Args:
-            router: FastAPI router for registering endpoints
-            dispatcher: Command dispatcher providing access to registered commands
-        """
-        self.router = router
-        self.dispatcher = dispatcher
-        self.registered_endpoints = []
-    
-    def generate_endpoint(self, command_name: str, handler_func: Callable, metadata: Dict[str, Any]) -> None:
-        """
-        Generates REST API endpoint for specified command.
-        
-        Args:
-            command_name: Command name
-            handler_func: Command handler function
-            metadata: Command metadata from docstring
-        """
-        # Get function signature
-        sig = inspect.signature(handler_func)
-        
-        # Create request model based on function parameters
-        param_fields = {}
-        for name, param in sig.parameters.items():
-            # Skip self parameter
-            if name == 'self':
-                continue
-                
-            # Get parameter type and default value
-            param_type = param.annotation if param.annotation != inspect.Parameter.empty else Any
-            default_value = ... if param.default == inspect.Parameter.empty else param.default
-            
-            # Add field to model
-            param_fields[name] = (param_type, default_value)
-        
-        # Create request model
-        request_model = create_model(
-            f"{command_name.capitalize()}Request",
-            **param_fields
-        )
-        
-        # Create endpoint
-        endpoint_path = f"/{command_name}"
-        
-        # Define endpoint handler
-        async def endpoint_handler(request_data: request_model):
-            # Call command through dispatcher
-            try:
-                # Get parameters from model
-                params = request_data.__dict__ if hasattr(request_data, "__dict__") else {}
-                
-                # Call dispatcher's execute method
-                result = self.dispatcher.execute(command_name, **params)
-                
-                # If result is coroutine, await its completion
-                if inspect.iscoroutine(result):
-                    result = await result
-                
-                return {"success": True, "result": result}
-            except Exception as e:
-                raise HTTPException(status_code=500, detail=str(e))
-        
-        # Add documentation from metadata
-        if 'description' in metadata:
-            endpoint_handler.__doc__ = metadata['description']
-        
-        # Register endpoint
-        self.router.post(endpoint_path, response_model=None)(endpoint_handler)
-        self.registered_endpoints.append(endpoint_path)
-    
-    def generate_all_endpoints(self) -> List[str]:
-        """
-        Generates endpoints for all registered commands.
-        
-        Returns:
-            List[str]: List of created endpoints
-        """
-        # Create endpoints for all commands
-        commands_info = self.dispatcher.get_commands_info()
-        
-        for command_name, command_info in commands_info.items():
-            # Get command handler
-            handler = self.dispatcher._handlers[command_name] if hasattr(self.dispatcher, "_handlers") else None
-            
-            # If handler couldn't be obtained, skip command
-            if not handler:
-                continue
-                
-            self.generate_endpoint(
-                command_name, 
-                handler, 
-                command_info
-            )
-        
-        # Create help endpoint
-        self.generate_help_endpoint()
-        
-        return self.registered_endpoints
-    
-    def generate_help_endpoint(self) -> None:
-        """
-        Creates special /help endpoint that returns information
-        about all available commands and their endpoints.
-        """
-        async def help_handler(command: Optional[str] = None):
-            if command:
-                # If specific command is specified, return information about it
-                command_info = self.dispatcher.get_command_info(command)
-                if not command_info:
-                    return {
-                        "success": False,
-                        "error": f"Command '{command}' not found",
-                        "available_commands": self.dispatcher.get_valid_commands()
-                    }
-                
-                # Add endpoint URL
-                endpoint_path = f"/{command}"
-                
-                return {
-                    "success": True,
-                    "command": command,
-                    "info": command_info,
-                    "endpoint": endpoint_path
-                }
-            
-            # Otherwise return information about all commands
-            commands_info = {}
-            for cmd in self.dispatcher.get_valid_commands():
-                info = self.dispatcher.get_command_info(cmd)
-                if not info:
-                    continue
-                    
-                endpoint_path = f"/{cmd}"
-                commands_info[cmd] = {
-                    "summary": info.get("summary", ""),
-                    "description": info.get("description", ""),
-                    "endpoint": endpoint_path,
-                    "params_count": len(info.get("params", {}))
-                }
-            
-            return {
-                "success": True,
-                "commands": commands_info,
-                "total": len(commands_info),
-                "endpoints": self.registered_endpoints,
-                "note": "Use 'command' parameter to get detailed information about a specific command"
-            }
-        
-        help_handler.__doc__ = "Get list of all available commands and API endpoints"
-        self.router.get("/help", response_model=None)(help_handler)
-        self.registered_endpoints.append("/help")