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

dispatchers/json_rpc_dispatcher.py

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

@@ -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") 

generators/openapi_generator.py

@@ -1,254 +0,0 @@
-"""
-OpenAPI schema generator for API documentation based on registered commands.
-"""
-from typing import Any, Dict, List, Optional, Callable
-import inspect
-from pydantic import BaseModel, create_model
-
-class OpenApiGenerator:
-    """
-    OpenAPI schema generator for API documentation based on registered commands.
-    
-    Creates OpenAPI schema describing all registered commands and their parameters
-    for use in automatic API documentation.
-    """
-    
-    def __init__(self, dispatcher: Any, title: str = "Vector Store API", 
-                 version: str = "1.0.0", description: str = "Vector Store API Documentation"):
-        """
-        Initialize OpenAPI schema generator.
-        
-        Args:
-            dispatcher: Command dispatcher providing access to registered commands
-            title: API title
-            version: API version
-            description: API description
-        """
-        self.dispatcher = dispatcher
-        self.title = title
-        self.version = version
-        self.description = description
-    
-    def generate_schema(self) -> Dict[str, Any]:
-        """
-        Generates complete OpenAPI schema for all registered commands.
-        
-        Returns:
-            Dict[str, Any]: OpenAPI schema as dictionary
-        """
-        # Base OpenAPI schema structure
-        schema = {
-            "openapi": "3.0.0",
-            "info": {
-                "title": self.title,
-                "version": self.version,
-                "description": self.description
-            },
-            "paths": {},
-            "components": {
-                "schemas": {}
-            }
-        }
-        
-        # Get all registered commands
-        commands = self.dispatcher.get_registered_commands()
-        
-        # Generate schemas for each command
-        for command_name, command_data in commands.items():
-            handler_func = command_data['handler']
-            metadata = command_data.get('metadata', {})
-            
-            # Add path for endpoint
-            path = f"/{command_name}"
-            method = "post"  # By default all commands are handled via POST
-            
-            # Get request schema
-            request_schema = self._generate_request_schema(command_name, handler_func)
-            
-            # Add response schema
-            response_schema = self._generate_response_schema(command_name, handler_func, metadata)
-            
-            # Add path to schema
-            schema["paths"][path] = {
-                method: {
-                    "summary": metadata.get('summary', f"Execute {command_name} command"),
-                    "description": metadata.get('description', ""),
-                    "operationId": f"{command_name}",
-                    "requestBody": {
-                        "required": True,
-                        "content": {
-                            "application/json": {
-                                "schema": request_schema
-                            }
-                        }
-                    },
-                    "responses": {
-                        "200": {
-                            "description": "Successful operation",
-                            "content": {
-                                "application/json": {
-                                    "schema": response_schema
-                                }
-                            }
-                        },
-                        "500": {
-                            "description": "Internal server error",
-                            "content": {
-                                "application/json": {
-                                    "schema": {
-                                        "type": "object",
-                                        "properties": {
-                                            "success": {
-                                                "type": "boolean",
-                                                "example": False
-                                            },
-                                            "error": {
-                                                "type": "string"
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        
-        # Add /help endpoint
-        schema["paths"]["/help"] = {
-            "get": {
-                "summary": "Get API help",
-                "description": "Get list of all available commands and API endpoints",
-                "operationId": "getHelp",
-                "responses": {
-                    "200": {
-                        "description": "Successful operation",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "type": "object",
-                                    "properties": {
-                                        "success": {
-                                            "type": "boolean",
-                                            "example": True
-                                        },
-                                        "registered_commands": {
-                                            "type": "object",
-                                            "additionalProperties": {
-                                                "type": "object",
-                                                "properties": {
-                                                    "endpoint": {
-                                                        "type": "string"
-                                                    },
-                                                    "description": {
-                                                        "type": "string"
-                                                    },
-                                                    "parameters": {
-                                                        "type": "object"
-                                                    }
-                                                }
-                                            }
-                                        },
-                                        "endpoints": {
-                                            "type": "array",
-                                            "items": {
-                                                "type": "string"
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        
-        return schema
-    
-    def _generate_request_schema(self, command_name: str, handler_func: Callable) -> Dict[str, Any]:
-        """
-        Generates request schema for specified command.
-        
-        Args:
-            command_name: Command name
-            handler_func: Command handler function
-            
-        Returns:
-            Dict[str, Any]: Request schema in OpenAPI format
-        """
-        # Get function signature
-        sig = inspect.signature(handler_func)
-        
-        # Create request schema
-        properties = {}
-        required = []
-        
-        for name, param in sig.parameters.items():
-            # Skip self parameter
-            if name == 'self':
-                continue
-                
-            # Get parameter type
-            param_type = param.annotation if param.annotation != inspect.Parameter.empty else Any
-            
-            # Determine type for OpenAPI
-            if param_type == str:
-                prop_type = {"type": "string"}
-            elif param_type == int:
-                prop_type = {"type": "integer"}
-            elif param_type == float:
-                prop_type = {"type": "number"}
-            elif param_type == bool:
-                prop_type = {"type": "boolean"}
-            elif param_type == list or param_type == List:
-                prop_type = {"type": "array", "items": {"type": "string"}}
-            elif param_type == dict or param_type == Dict:
-                prop_type = {"type": "object"}
-            else:
-                prop_type = {"type": "object"}
-            
-            # Add property to schema
-            properties[name] = prop_type
-            
-            # If parameter is required, add it to required list
-            if param.default == inspect.Parameter.empty:
-                required.append(name)
-        
-        schema = {
-            "type": "object",
-            "properties": properties
-        }
-        
-        if required:
-            schema["required"] = required
-            
-        return schema
-    
-    def _generate_response_schema(self, command_name: str, handler_func: Callable, 
-                                 metadata: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Generates response schema for specified command.
-        
-        Args:
-            command_name: Command name
-            handler_func: Command handler function
-            metadata: Command metadata
-            
-        Returns:
-            Dict[str, Any]: Response schema in OpenAPI format
-        """
-        # Base response structure
-        return {
-            "type": "object",
-            "properties": {
-                "success": {
-                    "type": "boolean",
-                    "example": True
-                },
-                "result": {
-                    "type": "object",
-                    "description": metadata.get("returns", "Command result")
-                }
-            }
-        }