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

generators/endpoint_generator.py

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

@@ -0,0 +1,254 @@
+"""
+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")
+                }
+            }
+        } 

generators/rest_api_generator.py

@@ -0,0 +1,207 @@
+"""
+Генератор REST API на основе команд и их метаданных.
+"""
+from typing import Dict, Any, Optional, List, Callable
+import inspect
+import logging
+from command_registry.dispatchers.base_dispatcher import BaseDispatcher
+
+logger = logging.getLogger("command_registry")
+
+class RestApiGenerator:
+    """
+    Генератор REST API для FastAPI на основе команд.
+    
+    Этот класс создает REST эндпоинты для FastAPI на основе
+    зарегистрированных команд и их метаданных.
+    """
+    
+    def __init__(self, app, dispatcher: Optional[BaseDispatcher] = None, prefix: str = ""):
+        """
+        Инициализирует генератор REST API.
+        
+        Args:
+            app: Экземпляр FastAPI приложения
+            dispatcher: Диспетчер команд для доступа к метаданным
+            prefix: Префикс для всех эндпоинтов (например, "/api")
+        """
+        self.app = app
+        self.dispatcher = dispatcher
+        self.prefix = prefix.rstrip("/")
+        
+        # Словарь для хранения соответствия между командами и эндпоинтами
+        self._endpoints = {}
+    
+    def set_dispatcher(self, dispatcher: BaseDispatcher) -> None:
+        """
+        Устанавливает диспетчер команд.
+        
+        Args:
+            dispatcher: Диспетчер команд
+        """
+        self.dispatcher = dispatcher
+    
+    def generate_endpoints(self) -> None:
+        """
+        Генерирует REST эндпоинты для всех команд.
+        
+        Создает эндпоинты для всех команд, зарегистрированных в диспетчере,
+        включая автоматический хелп-эндпоинт.
+        """
+        if not self.dispatcher:
+            logger.warning("Диспетчер команд не установлен, невозможно сгенерировать эндпоинты")
+            return
+        
+        # Получаем информацию о всех командах
+        commands_info = self.dispatcher.get_commands_info()
+        
+        # Генерируем эндпоинты для каждой команды
+        for command, info in commands_info.items():
+            # Генерируем путь для эндпоинта
+            path = f"{self.prefix}/{command.replace('_', '-')}"
+            
+            # Генерируем обработчик для эндпоинта
+            endpoint = self._create_endpoint_handler(command, info)
+            
+            # Регистрируем эндпоинт в FastAPI
+            self.app.post(
+                path,
+                summary=info.get("summary", command),
+                description=info.get("description", ""),
+                tags=self._get_tags_for_command(command)
+            )(endpoint)
+            
+            # Сохраняем соответствие между командой и эндпоинтом
+            self._endpoints[command] = path
+            
+            logger.debug(f"Сгенерирован REST эндпоинт для команды '{command}': {path}")
+        
+        # Генерируем хелп-эндпоинт
+        self._generate_help_endpoint()
+    
+    def _create_endpoint_handler(self, command: str, info: Dict[str, Any]) -> Callable:
+        """
+        Создает функцию-обработчик для эндпоинта.
+        
+        Args:
+            command: Имя команды
+            info: Метаданные команды
+            
+        Returns:
+            Callable: Функция-обработчик для FastAPI
+        """
+        dispatcher = self.dispatcher
+        
+        # Создаем динамическую функцию-обработчик
+        async def endpoint(**kwargs):
+            try:
+                # Выполняем команду через диспетчер
+                result = dispatcher.execute(command, **kwargs)
+                
+                # Если результат корутина, ожидаем его завершения
+                if inspect.iscoroutine(result):
+                    result = await result
+                
+                return result
+            except Exception as e:
+                # В случае ошибки возвращаем структурированный ответ с ошибкой
+                return {
+                    "error": {
+                        "message": str(e),
+                        "code": 500
+                    }
+                }
+        
+        # Устанавливаем имя функции и докстринг
+        endpoint.__name__ = f"{command}_endpoint"
+        endpoint.__doc__ = info.get("description", "")
+        
+        # Возвращаем функцию-обработчик
+        return endpoint
+    
+    def _generate_help_endpoint(self) -> None:
+        """
+        Генерирует хелп-эндпоинт для API.
+        
+        Создает специальный эндпоинт /help, который возвращает информацию
+        о всех доступных командах и их эндпоинтах.
+        """
+        app = self.app
+        dispatcher = self.dispatcher
+        endpoints = self._endpoints
+        
+        # Путь для хелп-эндпоинта
+        help_path = f"{self.prefix}/help"
+        
+        # Функция-обработчик для хелп-эндпоинта
+        async def help_endpoint(command: Optional[str] = None):
+            if command:
+                # Если указана конкретная команда, возвращаем информацию о ней
+                command_info = dispatcher.get_command_info(command)
+                if not command_info:
+                    return {
+                        "error": f"Команда '{command}' не найдена",
+                        "available_commands": list(dispatcher.get_valid_commands())
+                    }
+                
+                # Добавляем URL эндпоинта
+                endpoint_url = endpoints.get(command)
+                if endpoint_url:
+                    command_info["endpoint"] = endpoint_url
+                
+                return {
+                    "command": command,
+                    "info": command_info
+                }
+            
+            # Иначе возвращаем информацию о всех командах
+            commands_info = {}
+            for cmd, info in dispatcher.get_commands_info().items():
+                endpoint_url = endpoints.get(cmd)
+                commands_info[cmd] = {
+                    "summary": info.get("summary", ""),
+                    "description": info.get("description", ""),
+                    "endpoint": endpoint_url,
+                    "params_count": len(info.get("params", {}))
+                }
+            
+            return {
+                "commands": commands_info,
+                "total": len(commands_info),
+                "base_url": self.prefix,
+                "note": "Для получения подробной информации о команде используйте параметр 'command'"
+            }
+        
+        # Регистрируем хелп-эндпоинт в FastAPI
+        app.get(
+            help_path,
+            summary="API справка",
+            description="Возвращает информацию о доступных командах и эндпоинтах API",
+            tags=["help"]
+        )(help_endpoint)
+        
+        logger.debug(f"Сгенерирован хелп-эндпоинт: {help_path}")
+    
+    def _get_tags_for_command(self, command: str) -> List[str]:
+        """
+        Определяет теги для команды.
+        
+        Args:
+            command: Имя команды
+            
+        Returns:
+            List[str]: Список тегов для документации OpenAPI
+        """
+        # Простая эвристика для определения категории команды
+        if command.startswith(("get_", "search_", "find_", "list_")):
+            return ["query"]
+        elif command.startswith(("create_", "add_", "insert_")):
+            return ["mutation", "create"]
+        elif command.startswith(("update_", "change_", "modify_")):
+            return ["mutation", "update"]
+        elif command.startswith(("delete_", "remove_")):
+            return ["mutation", "delete"]
+        else:
+            # Используем первую часть имени команды в качестве тега
+            parts = command.split("_")
+            return [parts[0]] if parts else ["other"]