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

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

generators/rest_api_generator.py

@@ -1,207 +0,0 @@
-"""
-Генератор 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"] 

mcp_proxy_adapter-2.1.0.dist-info/RECORD

@@ -1,28 +0,0 @@
-adapters/__init__.py,sha256=7QraK1j5y29KFSRF4mVxTiWC2Y3IYZLd6GhxUCtjyhg,790
-analyzers/__init__.py,sha256=2rcYZDP-bXq078MQpxP32lAwYYyRhOwAQGBcefBfBzY,368
-analyzers/docstring_analyzer.py,sha256=T3FLJEo_uChShfiEKRl8GpVoHvh5HiudZkxnj4KixfA,7541
-analyzers/type_analyzer.py,sha256=6Wac7osKwF03waFSwQ8ZM0Wqn_zAP2D-I4WMEpR0hQM,5230
-cli/__init__.py,sha256=vJ0VTT7D4KRIOi9nQSgBLub7xywq68i2R1zYQkdA0Uk,416
-cli/__main__.py,sha256=qtjEOB4vkeMASjTppyRFok4IFihRrVOqjk6vLx8OW1g,2400
-cli/command_runner.py,sha256=4d0BZKRG9k4CLk3ZE26jfSxwwrls2e-KsflRoVimfyE,8328
-dispatchers/__init__.py,sha256=FWgimgInGphIjCEnvA3-ZExiapUzYAVis2H9C5IWivU,365
-dispatchers/base_dispatcher.py,sha256=S5_Xri058jAmOWeit1tedB_GMZQ9RLcNcYabA83ZF6k,2288
-dispatchers/json_rpc_dispatcher.py,sha256=ffu1M32E1AdC7IB44mlbV2L56eJQMsp-7fYi_r4rmHc,6331
-generators/__init__.py,sha256=KC8p2HcIBqdyCY1wHnN_c1EfbnPM39YhZLNBDcuv3vA,538
-generators/endpoint_generator.py,sha256=fhEInY3JPwdc5EENesN9VrrONwVZMpsledVpubouJLA,6513
-generators/openapi_generator.py,sha256=0Iqsn0fRr10sTWUK9-MU5MXOXKDHccxKYnmaiQPkKFw,9773
-generators/rest_api_generator.py,sha256=Zg9HVeIuspowXd6aBlyho4UXz-te_Hd4egGzjjIVF48,9159
-mcp_proxy_adapter-2.1.0.dist-info/licenses/LICENSE,sha256=OkApFEwdgMCt_mbvUI-eIwKMSTe38K3XnU2DT5ub-wI,1072
-openapi_schema/__init__.py,sha256=S_lEg-VtlgDdhFxB_u9ZUM1dWKbzW_L_FM-6OCT4EXM,1334
-openapi_schema/command_registry.py,sha256=VqqdsVCcd5neqZ-bsfeKTHeLBeputwUZHxvNxVuvqZs,12075
-openapi_schema/rest_schema.py,sha256=nfF9axtmEA-B-Rw8TCnpmRf6Br3MfQ3TJVx-QHUHoy8,24103
-openapi_schema/rpc_generator.py,sha256=5FGMqjMXcaW0Ej6oey5mgiIxtEKTtA87dc-_kWLWqb0,13640
-openapi_schema/rpc_schema.py,sha256=pebSNt9rKyP2dyHpbjSllak6pQe5AnllReKHhR3UIaI,20162
-validators/__init__.py,sha256=s6zd5oZ3V2pXtzONoH3CiZYLzSVtCoLXpETMFUQfwWY,403
-validators/base_validator.py,sha256=qTEcXnfGqsgKKtc-lnttLiPTuq6vOHfDpZrQ5oP5Fi0,602
-validators/docstring_validator.py,sha256=Onpq2iNJ1qF4ejkJJIlBkLROuSNIVALHVmXIgkCpaFI,2934
-validators/metadata_validator.py,sha256=uCrn38-VYYn89l6f5CC_GoTAHAweaOW2Z6Esro1rtGw,3155
-mcp_proxy_adapter-2.1.0.dist-info/METADATA,sha256=NzrDAS6Q9E1vrPY-xzm72Uq09hncset_5NrFyIYPDvc,8158
-mcp_proxy_adapter-2.1.0.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-mcp_proxy_adapter-2.1.0.dist-info/top_level.txt,sha256=SlVzE4ry_0xTgDmO2uiaI7ihb9MpR62izN4MH_t1BTU,72
-mcp_proxy_adapter-2.1.0.dist-info/RECORD,,

mcp_proxy_adapter-2.1.0.dist-info/top_level.txt

@@ -1,7 +0,0 @@
-adapters
-analyzers
-cli
-dispatchers
-generators
-openapi_schema
-validators

openapi_schema/__init__.py

@@ -1,38 +0,0 @@
-"""
-Combined OpenAPI schema for REST and RPC API.
-Provides the get_openapi_schema function that returns the complete OpenAPI schema.
-"""
-from typing import Dict, Any
-
-from .rest_schema import get_rest_schema
-from .rpc_generator import generate_rpc_schema
-
-__all__ = ["get_openapi_schema"]
-
-
-def get_openapi_schema() -> Dict[str, Any]:
-    """
-    Gets the complete OpenAPI schema that includes both REST and RPC interfaces.
-    
-    Returns:
-        Dict[str, Any]: Complete OpenAPI schema
-    """
-    # Get the base REST schema
-    openapi_schema = get_rest_schema()
-    
-    # Generate RPC schema based on REST schema
-    rpc_schema = generate_rpc_schema(openapi_schema)
-    
-    # Add /cmd endpoint from RPC schema to the general schema
-    openapi_schema["paths"].update(rpc_schema["paths"])
-    
-    # Merge schema components
-    for component_type, components in rpc_schema["components"].items():
-        if component_type not in openapi_schema["components"]:
-            openapi_schema["components"][component_type] = {}
-        for component_name, component in components.items():
-            # Avoid component duplication
-            if component_name not in openapi_schema["components"][component_type]:
-                openapi_schema["components"][component_type][component_name] = component
-    
-    return openapi_schema