mcp-proxy-adapter 2.1.16__py3-none-any.whl → 3.0.0__py3-none-any.whl

examples/minimal_example/tests/test_integration.py

@@ -0,0 +1,183 @@
+"""
+Integration tests for the minimal example microservice.
+
+These tests start a real server instance and test the API endpoints.
+"""
+
+import os
+import time
+import pytest
+import requests
+from typing import Dict, Any, Callable
+
+from conftest import ServerProcess
+
+
+class TestHelloCommandIntegration:
+    """Integration tests for the HelloCommand API."""
+
+    def test_jsonrpc_hello_default(self, server: ServerProcess, jsonrpc_client: Callable):
+        """Test the hello command via JSON-RPC with default parameters."""
+        # Make JSON-RPC request
+        response = jsonrpc_client("hello", {})
+        
+        # Check response
+        assert "jsonrpc" in response
+        assert response["jsonrpc"] == "2.0"
+        assert "id" in response
+        assert "result" in response
+        assert "message" in response["result"]
+        assert response["result"]["message"] == "Hello, World!"
+    
+    def test_jsonrpc_hello_custom_name(self, server: ServerProcess, jsonrpc_client: Callable):
+        """Test the hello command via JSON-RPC with custom name parameter."""
+        # Make JSON-RPC request
+        response = jsonrpc_client("hello", {"name": "Integration Test"})
+        
+        # Check response
+        assert "result" in response
+        assert "message" in response["result"]
+        assert response["result"]["message"] == "Hello, Integration Test!"
+    
+    def test_cmd_endpoint_hello(self, server: ServerProcess, api_url: str):
+        """Test the hello command via the /cmd endpoint."""
+        # Prepare request
+        payload = {
+            "command": "hello",
+            "params": {"name": "CMD Endpoint"}
+        }
+        
+        # Make request
+        response = requests.post(
+            f"{api_url}/cmd",
+            json=payload,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        # Check response
+        assert response.status_code == 200
+        data = response.json()
+        assert "result" in data
+        assert "message" in data["result"]
+        assert data["result"]["message"] == "Hello, CMD Endpoint!"
+    
+    def test_api_command_endpoint_hello(self, server: ServerProcess, api_url: str):
+        """Test the hello command via the /api/command/{command_name} endpoint."""
+        # Prepare params
+        params = {"name": "API Command Endpoint"}
+        
+        # Make request
+        response = requests.post(
+            f"{api_url}/api/command/hello",
+            json=params,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        # Check response
+        assert response.status_code == 200
+        data = response.json()
+        assert "message" in data
+        assert data["message"] == "Hello, API Command Endpoint!"
+    
+    def test_jsonrpc_batch_request(self, server: ServerProcess, api_url: str):
+        """Test batch JSON-RPC requests with hello command."""
+        # Prepare batch request
+        batch = [
+            {
+                "jsonrpc": "2.0",
+                "method": "hello",
+                "params": {"name": "Batch 1"},
+                "id": 1
+            },
+            {
+                "jsonrpc": "2.0",
+                "method": "hello",
+                "params": {"name": "Batch 2"},
+                "id": 2
+            }
+        ]
+        
+        # Make request
+        response = requests.post(
+            f"{api_url}/api/jsonrpc",
+            json=batch,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        # Check response
+        assert response.status_code == 200
+        data = response.json()
+        assert isinstance(data, list)
+        assert len(data) == 2
+        
+        # Check first result
+        assert data[0]["id"] == 1
+        assert data[0]["result"]["message"] == "Hello, Batch 1!"
+        
+        # Check second result
+        assert data[1]["id"] == 2
+        assert data[1]["result"]["message"] == "Hello, Batch 2!"
+
+
+class TestServerIntegration:
+    """Integration tests for the server itself."""
+    
+    def test_health_endpoint(self, server: ServerProcess, api_url: str):
+        """Test the /health endpoint."""
+        response = requests.get(f"{api_url}/health")
+        
+        # Check response
+        assert response.status_code == 200
+        data = response.json()
+        assert "status" in data
+        assert data["status"] == "ok"
+    
+    def test_openapi_schema(self, server: ServerProcess, api_url: str):
+        """Test the OpenAPI schema endpoint."""
+        response = requests.get(f"{api_url}/openapi.json")
+        
+        # Check response
+        assert response.status_code == 200
+        schema = response.json()
+        
+        # Check schema structure
+        assert "openapi" in schema
+        assert "info" in schema
+        assert "paths" in schema
+        
+        # Check hello command paths
+        assert "/api/command/hello" in schema["paths"]
+        assert "/api/jsonrpc" in schema["paths"]
+        
+    def test_docs_endpoint(self, server: ServerProcess, api_url: str):
+        """Test the Swagger UI endpoint."""
+        response = requests.get(f"{api_url}/docs")
+        
+        # Check response
+        assert response.status_code == 200
+        assert "text/html" in response.headers["Content-Type"]
+        
+        # Check if swagger UI is in the response
+        assert "swagger-ui" in response.text.lower()
+    
+    def test_commands_list_endpoint(self, server: ServerProcess, api_url: str):
+        """Test the commands list endpoint."""
+        response = requests.get(f"{api_url}/api/commands")
+        
+        # Check response
+        assert response.status_code == 200
+        data = response.json()
+        
+        # Check data structure
+        assert "commands" in data
+        assert isinstance(data["commands"], list)
+        
+        # Check if hello command is in the list
+        hello_commands = [cmd for cmd in data["commands"] if cmd["name"] == "hello"]
+        assert len(hello_commands) == 1
+        
+        # Check hello command details
+        hello_cmd = hello_commands[0]
+        assert "name" in hello_cmd
+        assert "description" in hello_cmd
+        assert "parameters" in hello_cmd 

examples/server.py

@@ -0,0 +1,69 @@
+"""
+Main application module.
+"""
+
+import os
+import sys
+import uvicorn
+import logging
+
+from mcp_proxy_adapter import create_app
+
+app = create_app()
+from mcp_proxy_adapter.config import config
+from mcp_proxy_adapter.core.logging import logger, setup_logging
+
+
+def main():
+    """
+    Main function to run the application.
+    """
+    # Убедимся что логирование настроено
+    logger.info("Initializing logging configuration")
+    
+    try:
+        # Получаем настройки логирования
+        log_level = config.get("logging.level", "INFO")
+        log_file = config.get("logging.file")
+        rotation_type = config.get("logging.rotation.type", "size")
+        
+        # Выводим информацию о настройках логирования
+        logger.info(f"Log level: {log_level}")
+        if log_file:
+            logger.info(f"Log file: {log_file}")
+            logger.info(f"Log rotation type: {rotation_type}")
+            
+            if rotation_type.lower() == "time":
+                when = config.get("logging.rotation.when", "D")
+                interval = config.get("logging.rotation.interval", 1)
+                logger.info(f"Log rotation: every {interval} {when}")
+            else:
+                max_bytes = config.get("logging.rotation.max_bytes", 10 * 1024 * 1024)
+                logger.info(f"Log rotation: when size reaches {max_bytes / (1024*1024):.1f} MB")
+                
+            backup_count = config.get("logging.rotation.backup_count", 5)
+            logger.info(f"Log backups: {backup_count}")
+        else:
+            logger.info("File logging is disabled")
+            
+        # Get server settings
+        host = config.get("server.host", "0.0.0.0")
+        port = config.get("server.port", 8000)
+        
+        logger.info(f"Starting server on {host}:{port}")
+        
+        # Run server
+        uvicorn.run(
+            "mcp_proxy_adapter.api.app:app",
+            host=host,
+            port=port,
+            reload=True if os.environ.get("DEBUG") else False,
+            log_level=log_level.lower()
+        )
+    except Exception as e:
+        logger.exception(f"Error during application startup: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

examples/simple_server.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""
+Простой пример запуска сервера JSON-RPC с использованием MCP Proxy Adapter.
+
+Этот скрипт демонстрирует минимальную конфигурацию для запуска сервера JSON-RPC.
+Он создаёт экземпляр MicroService, регистрирует несколько команд и запускает сервер.
+"""
+
+import os
+import argparse
+import sys
+from pathlib import Path
+
+# Добавляем родительскую директорию в PYTHONPATH для импорта mcp_proxy_adapter
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import mcp_proxy_adapter as mcp
+from mcp_proxy_adapter.framework import MicroService
+from examples.commands.echo_command import EchoCommand
+from examples.commands.get_date_command import GetDateCommand
+from examples.commands.new_uuid4_command import NewUuid4Command
+from typing import Dict, Any, Optional
+from mcp_proxy_adapter import Command, SuccessResult
+
+
+class HelloResult(SuccessResult):
+    """Result of hello command."""
+    
+    def __init__(self, message: str):
+        """
+        Initialize result.
+        
+        Args:
+            message: Hello message
+        """
+        self.message = message
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dictionary representation
+        """
+        return {"message": self.message}
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for result.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "message": {"type": "string"}
+            },
+            "required": ["message"]
+        }
+
+
+class HelloCommand(Command):
+    """Command that returns hello message."""
+    
+    name = "hello"
+    result_class = HelloResult
+    
+    async def execute(self, name: str = "World") -> HelloResult:
+        """
+        Execute command.
+        
+        Args:
+            name: Name to greet
+            
+        Returns:
+            Hello result
+        """
+        return HelloResult(f"Hello, {name}!")
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"}
+            },
+            "additionalProperties": False
+        }
+
+
+def main():
+    """
+    Основная функция для запуска сервера.
+    """
+    parser = argparse.ArgumentParser(description="JSON-RPC Microservice Server")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind server")
+    parser.add_argument("--port", type=int, default=8000, help="Port to bind server")
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload")
+    parser.add_argument("--config", help="Path to config file")
+    
+    args = parser.parse_args()
+    
+    # Создаем экземпляр микросервиса
+    service = MicroService(
+        title="Simple Example Service",
+        description="Example microservice demonstrating basic functionality",
+        version="1.0.0",
+        config_path=args.config
+    )
+    
+    # Регистрируем команды
+    service.register_command(EchoCommand)
+    service.register_command(GetDateCommand)
+    service.register_command(NewUuid4Command)
+    
+    # Запускаем сервер
+    service.run(
+        host=args.host,
+        port=args.port,
+        reload=args.reload
+    )
+
+
+if __name__ == "__main__":
+    # Run the simple server example
+    # To test, open http://localhost:8000/docs in your browser
+    # or use curl:
+    # curl -X POST http://localhost:8000/api/jsonrpc -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","method":"hello","params":{"name":"PyPI"},"id":1}'
+    main() 

examples/test_server.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""
+Тестовый скрипт для запуска сервера JSON-RPC с использованием MCP Proxy Adapter.
+Использует только базовую команду для тестирования установки пакета.
+"""
+
+import os
+import argparse
+import sys
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+# Добавляем родительскую директорию в PYTHONPATH для импорта mcp_proxy_adapter
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from mcp_proxy_adapter.framework import MicroService
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import SuccessResult
+
+
+class HelloResult(SuccessResult):
+    """Result of hello command."""
+    
+    def __init__(self, message: str):
+        """
+        Initialize result.
+        
+        Args:
+            message: Hello message
+        """
+        self.message = message
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dictionary representation
+        """
+        return {"message": self.message}
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for result.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "message": {"type": "string"}
+            },
+            "required": ["message"]
+        }
+
+
+class HelloCommand(Command):
+    """Command that returns hello message."""
+    
+    name = "hello"
+    result_class = HelloResult
+    
+    async def execute(self, name: str = "World") -> HelloResult:
+        """
+        Execute command.
+        
+        Args:
+            name: Name to greet
+            
+        Returns:
+            Hello result
+        """
+        return HelloResult(f"Hello, {name}!")
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"}
+            },
+            "additionalProperties": False
+        }
+
+
+def main():
+    """
+    Основная функция для запуска сервера.
+    """
+    parser = argparse.ArgumentParser(description="Test JSON-RPC Microservice Server")
+    parser.add_argument("--host", default="localhost", help="Host to bind server")
+    parser.add_argument("--port", type=int, default=8000, help="Port to bind server")
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload")
+    parser.add_argument("--config", help="Path to config file")
+    
+    args = parser.parse_args()
+    
+    # Создаем экземпляр микросервиса
+    service = MicroService(
+        title="Test Microservice",
+        description="Test microservice for package installation verification",
+        version="1.0.0",
+        config_path=args.config
+    )
+    
+    # Регистрируем только одну команду для тестирования
+    service.register_command(HelloCommand)
+    
+    # Запускаем сервер
+    service.run(
+        host=args.host,
+        port=args.port,
+        reload=args.reload
+    )
+
+
+if __name__ == "__main__":
+    main() 

mcp_proxy_adapter/__init__.py

@@ -1 +1,33 @@
- 
+"""MCP Proxy API Service package.
+
+This package provides a framework for creating JSON-RPC-enabled microservices.
+"""
+
+from mcp_proxy_adapter.version import __version__
+from mcp_proxy_adapter.api.app import create_app
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult, ErrorResult
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.core.errors import (
+    MicroserviceError, CommandError, ValidationError, 
+    InvalidParamsError, NotFoundError, TimeoutError,
+    InternalError
+)
+
+# Экспортируем основные классы и функции для удобного использования
+__all__ = [
+    "__version__",
+    "create_app",
+    "Command",
+    "CommandResult", 
+    "SuccessResult",
+    "ErrorResult",
+    "registry",
+    "MicroserviceError",
+    "CommandError",
+    "ValidationError",
+    "InvalidParamsError",
+    "NotFoundError",
+    "TimeoutError",
+    "InternalError"
+]