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

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.0.1.dist-info/METADATA

@@ -1,272 +0,0 @@
-Metadata-Version: 2.4
-Name: mcp-proxy-adapter
-Version: 2.0.1
-Summary: Adapter for exposing Command Registry commands as tools for AI models via MCP Proxy.
-Home-page: https://github.com/vasilyvz/mcp-proxy-adapter
-Author: Vasiliy VZ
-Author-email: Vasiliy VZ <vasilyvz@example.com>
-License: MIT
-Project-URL: Homepage, https://github.com/vasilyvz/mcp-proxy-adapter
-Project-URL: BugTracker, https://github.com/vasilyvz/mcp-proxy-adapter/issues
-Project-URL: Documentation, https://github.com/vasilyvz/mcp_proxy_adapter#readme
-Project-URL: Source, https://github.com/vasilyvz/mcp_proxy_adapter
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.9, <4
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: fastapi<1.0.0,>=0.95.0
-Requires-Dist: pydantic<3.0.0,>=2.0.0
-Requires-Dist: uvicorn<1.0.0,>=0.22.0
-Requires-Dist: docstring-parser<1.0.0,>=0.15
-Requires-Dist: typing-extensions<5.0.0,>=4.5.0
-Dynamic: author
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-python
-
-# MCP Proxy Adapter
-
-Adapter for integrating [Command Registry](docs/README.md) with MCP Proxy, allowing you to use commands as tools for AI models.
-
-## Overview
-
-MCP Proxy Adapter transforms commands registered in the Command Registry into a format compatible with MCP Proxy. This enables:
-
-1. Using existing commands as tools for AI models
-2. Creating a hybrid REST/JSON-RPC API for command execution
-3. Automatic generation of OpenAPI schemas optimized for MCP Proxy
-4. Managing tool metadata for better AI system integration
-
-## Installation
-
-```bash
-pip install mcp-proxy-adapter
-```
-
-## Quick Start
-
-```python
-from mcp_proxy_adapter import MCPProxyAdapter, CommandRegistry
-from fastapi import FastAPI
-
-# Create a command registry instance
-registry = CommandRegistry()
-
-# Register commands
-@registry.command
-def calculate_total(prices: list[float], discount: float = 0.0) -> float:
-    """
-    Calculates the total price with discount.
-    Args:
-        prices: List of item prices
-        discount: Discount percentage (0-100)
-    Returns:
-        Total price with discount
-    """
-    subtotal = sum(prices)
-    return subtotal * (1 - discount / 100)
-
-# Create FastAPI app
-app = FastAPI()
-
-# Create and configure MCP Proxy adapter
-adapter = MCPProxyAdapter(registry)
-
-# Register endpoints in FastAPI app
-adapter.register_endpoints(app)
-
-# Generate and save MCP Proxy config
-adapter.save_config_to_file("mcp_proxy_config.json")
-```
-
-## Supported Request Formats
-
-The adapter supports three request formats for command execution:
-
-### 1. JSON-RPC format
-
-```json
-{
-  "jsonrpc": "2.0",
-  "method": "command_name",
-  "params": {
-    "param1": "value1",
-    "param2": "value2"
-  },
-  "id": 1
-}
-```
-
-Example request to `/cmd` endpoint:
-
-```bash
-curl -X POST -H "Content-Type: application/json" -d '{
-  "jsonrpc": "2.0",
-  "method": "calculate_total",
-  "params": {
-    "prices": [100, 200, 300],
-    "discount": 10
-  },
-  "id": 1
-}' http://localhost:8000/cmd
-```
-
-Response:
-
-```json
-{
-  "jsonrpc": "2.0",
-  "result": 540.0,
-  "id": 1
-}
-```
-
-### 2. MCP Proxy format
-
-```json
-{
-  "command": "command_name",
-  "params": {
-    "param1": "value1",
-    "param2": "value2"
-  }
-}
-```
-
-Example request:
-
-```bash
-curl -X POST -H "Content-Type: application/json" -d '{
-  "command": "calculate_total",
-  "params": {
-    "prices": [100, 200, 300],
-    "discount": 10
-  }
-}' http://localhost:8000/cmd
-```
-
-Response:
-
-```json
-{
-  "result": 540.0
-}
-```
-
-### 3. Params-only format
-
-```json
-{
-  "params": {
-    "command": "command_name",
-    "param1": "value1",
-    "param2": "value2"
-  }
-}
-```
-
-or
-
-```json
-{
-  "params": {
-    "query": "command_name",
-    "param1": "value1",
-    "param2": "value2"
-  }
-}
-```
-
-Example request:
-
-```bash
-curl -X POST -H "Content-Type: application/json" -d '{
-  "params": {
-    "command": "calculate_total",
-    "prices": [100, 200, 300],
-    "discount": 10
-  }
-}' http://localhost:8000/cmd
-```
-
-Response:
-
-```json
-{
-  "result": 540.0
-}
-```
-
-## Full Example: Integration with FastAPI
-
-```python
-import logging
-from fastapi import FastAPI, APIRouter
-from mcp_proxy_adapter import CommandRegistry, MCPProxyAdapter, configure_logger
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-project_logger = logging.getLogger("my_project")
-
-# Create FastAPI app
-app = FastAPI(title="My API with MCP Proxy Integration")
-
-# Create existing API router
-router = APIRouter()
-
-@router.get("/items")
-async def get_items():
-    """Returns a list of items."""
-    return [
-        {"id": 1, "name": "Smartphone X", "price": 999.99},
-        {"id": 2, "name": "Laptop Y", "price": 1499.99},
-    ]
-
-app.include_router(router)
-
-# Register commands
-registry = CommandRegistry()
-
-@registry.command
-def get_discounted_price(price: float, discount: float = 0.0) -> float:
-    """
-    Returns the price after applying a discount.
-    """
-    return price * (1 - discount / 100)
-
-# Create and register MCP Proxy adapter
-adapter = MCPProxyAdapter(registry)
-adapter.register_endpoints(app)
-
-# Save MCP Proxy config
-adapter.save_config_to_file("mcp_proxy_config.json")
-```
-
-## Features
-- Universal JSON-RPC endpoint for command execution
-- Automatic OpenAPI schema generation and optimization for MCP Proxy
-- Tool metadata for AI models
-- Customizable endpoints and logging
-- Full test coverage and examples
-
-## License
-MIT
-
-## Documentation
-See [docs/](docs/) for detailed guides, architecture, and examples.
-
-## CI/CD & PyPI automation
-
-This project uses GitHub Actions for continuous integration and automated publishing to PyPI.
-
-- All tests are run on every push and pull request.
-- On push of a new tag (vX.Y.Z), the package is built and published to PyPI automatically.
-
-See `.github/workflows/publish.yml` for details. 

mcp_proxy_adapter-2.0.1.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.0.1.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.0.1.dist-info/METADATA,sha256=oP9RxZPEOhQdF_fPbj0t3gyN8u6lWRZBMETQ1gXno_k,6076
-mcp_proxy_adapter-2.0.1.dist-info/WHEEL,sha256=ooBFpIzZCPdw3uqIQsOo4qqbA4ZRPxHnOH7peeONza0,91
-mcp_proxy_adapter-2.0.1.dist-info/top_level.txt,sha256=SlVzE4ry_0xTgDmO2uiaI7ihb9MpR62izN4MH_t1BTU,72
-mcp_proxy_adapter-2.0.1.dist-info/RECORD,,

mcp_proxy_adapter-2.0.1.dist-info/licenses/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023-2024 Vasiliy VZ
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE. 

mcp_proxy_adapter-2.0.1.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