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

mcp_proxy_adapter/commands/result.py

@@ -0,0 +1,215 @@
+"""
+Module with base classes for command results.
+"""
+
+import json
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Type, TypeVar, Union
+
+T = TypeVar("T", bound="CommandResult")
+
+
+class CommandResult(ABC):
+    """
+    Base abstract class for command execution results.
+    """
+    
+    @abstractmethod
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Converts result to dictionary for serialization.
+
+        Returns:
+            Dictionary with result data.
+        """
+        pass
+    
+    @classmethod
+    @abstractmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Returns JSON schema for result validation.
+
+        Returns:
+            Dictionary with JSON schema.
+        """
+        pass
+    
+    def to_json(self, indent: Optional[int] = None) -> str:
+        """
+        Converts result to JSON string.
+
+        Args:
+            indent: Indentation for JSON formatting.
+
+        Returns:
+            JSON string with result.
+        """
+        return json.dumps(self.to_dict(), ensure_ascii=False, indent=indent)
+    
+    @classmethod
+    def from_dict(cls: Type[T], data: Dict[str, Any]) -> T:
+        """
+        Creates result instance from dictionary.
+        This method must be overridden in subclasses.
+
+        Args:
+            data: Dictionary with result data.
+
+        Returns:
+            Result instance.
+        """
+        raise NotImplementedError("Method from_dict must be implemented in subclasses")
+
+
+class SuccessResult(CommandResult):
+    """
+    Base class for successful command results.
+    """
+    
+    def __init__(self, data: Optional[Dict[str, Any]] = None, message: Optional[str] = None):
+        """
+        Initialize successful result.
+
+        Args:
+            data: Result data.
+            message: Result message.
+        """
+        self.data = data or {}
+        self.message = message
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Converts result to dictionary for serialization.
+
+        Returns:
+            Dictionary with result data.
+        """
+        result = {"success": True}
+        if self.data:
+            result["data"] = self.data
+        if self.message:
+            result["message"] = self.message
+        return result
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Returns JSON schema for result validation.
+
+        Returns:
+            Dictionary with JSON schema.
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "success": {"type": "boolean"},
+                "data": {"type": "object"},
+                "message": {"type": "string"}
+            },
+            "required": ["success"]
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SuccessResult":
+        """
+        Creates successful result instance from dictionary.
+
+        Args:
+            data: Dictionary with result data.
+
+        Returns:
+            Successful result instance.
+        """
+        return cls(
+            data=data.get("data"),
+            message=data.get("message")
+        )
+
+
+class ErrorResult(CommandResult):
+    """
+    Base class for command results with error.
+    
+    This class follows the JSON-RPC 2.0 error object format:
+    https://www.jsonrpc.org/specification#error_object
+    """
+    
+    def __init__(
+        self,
+        message: str,
+        code: int = -32000,
+        details: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Initialize error result.
+
+        Args:
+            message: Error message.
+            code: Error code (following JSON-RPC 2.0 spec).
+            details: Additional error details.
+        """
+        self.message = message
+        self.code = code
+        self.details = details or {}
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Converts result to dictionary for serialization.
+
+        Returns:
+            Dictionary with result data in JSON-RPC 2.0 error format.
+        """
+        result = {
+            "success": False,
+            "error": {
+                "code": self.code,
+                "message": self.message
+            }
+        }
+        if self.details:
+            result["error"]["data"] = self.details
+        return result
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Returns JSON schema for result validation.
+
+        Returns:
+            Dictionary with JSON schema.
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "success": {"type": "boolean"},
+                "error": {
+                    "type": "object",
+                    "properties": {
+                        "code": {"type": "integer"},
+                        "message": {"type": "string"},
+                        "data": {"type": "object"}
+                    },
+                    "required": ["code", "message"]
+                }
+            },
+            "required": ["success", "error"]
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ErrorResult":
+        """
+        Creates error result instance from dictionary.
+
+        Args:
+            data: Dictionary with result data.
+
+        Returns:
+            Error result instance.
+        """
+        error = data.get("error", {})
+        return cls(
+            message=error.get("message", "Unknown error"),
+            code=error.get("code", -32000),
+            details=error.get("data")
+        )

mcp_proxy_adapter/config.py

@@ -126,6 +126,15 @@ class Config:
             
         return value
 
+    def get_all(self) -> Dict[str, Any]:
+        """
+        Get all configuration values.
+
+        Returns:
+            Dictionary with all configuration values
+        """
+        return self.config_data.copy()
+
     def set(self, key: str, value: Any) -> None:
         """
         Set configuration value for key.

mcp_proxy_adapter/core/errors.py

@@ -0,0 +1,173 @@
+"""
+Module for defining errors and exceptions for the microservice.
+"""
+
+from typing import Any, Dict, List, Optional, Union
+
+
+class MicroserviceError(Exception):
+    """
+    Base class for all microservice exceptions.
+    
+    Attributes:
+        message: Error message.
+        code: Error code.
+        data: Additional error data.
+    """
+    def __init__(self, message: str, code: int = -32000, data: Optional[Dict[str, Any]] = None):
+        """
+        Initialize the error.
+
+        Args:
+            message: Error message.
+            code: Error code according to JSON-RPC standard.
+            data: Additional error data.
+        """
+        self.message = message
+        self.code = code
+        self.data = data or {}
+        super().__init__(message)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Converts the error to a dictionary for JSON-RPC response.
+
+        Returns:
+            Dictionary with error information.
+        """
+        result = {
+            "code": self.code,
+            "message": self.message
+        }
+        
+        if self.data:
+            result["data"] = self.data
+            
+        return result
+
+
+class ParseError(MicroserviceError):
+    """
+    Error while parsing JSON request.
+    JSON-RPC Error code: -32700
+    """
+    def __init__(self, message: str = "Parse error", data: Optional[Dict[str, Any]] = None):
+        super().__init__(message, code=-32700, data=data)
+
+
+class InvalidRequestError(MicroserviceError):
+    """
+    Invalid JSON-RPC request format.
+    JSON-RPC Error code: -32600
+    """
+    def __init__(self, message: str = "Invalid Request", data: Optional[Dict[str, Any]] = None):
+        super().__init__(message, code=-32600, data=data)
+
+
+class MethodNotFoundError(MicroserviceError):
+    """
+    Method not found error.
+    JSON-RPC Error code: -32601
+    """
+    def __init__(self, message: str = "Method not found", data: Optional[Dict[str, Any]] = None):
+        super().__init__(message, code=-32601, data=data)
+
+
+class InvalidParamsError(MicroserviceError):
+    """
+    Invalid method parameters.
+    JSON-RPC Error code: -32602
+    """
+    def __init__(self, message: str = "Invalid params", data: Optional[Dict[str, Any]] = None):
+        super().__init__(message, code=-32602, data=data)
+
+
+class InternalError(MicroserviceError):
+    """
+    Internal server error.
+    JSON-RPC Error code: -32603
+    """
+    def __init__(self, message: str = "Internal error", data: Optional[Dict[str, Any]] = None):
+        super().__init__(message, code=-32603, data=data)
+
+
+class ValidationError(MicroserviceError):
+    """
+    Input data validation error.
+    JSON-RPC Error code: -32602 (using Invalid params code)
+    """
+    def __init__(self, message: str = "Validation error", data: Optional[Dict[str, Any]] = None):
+        super().__init__(message, code=-32602, data=data)
+
+
+class CommandError(MicroserviceError):
+    """
+    Command execution error.
+    JSON-RPC Error code: -32000 (server error)
+    """
+    def __init__(self, message: str = "Command execution error", data: Optional[Dict[str, Any]] = None):
+        super().__init__(message, code=-32000, data=data)
+
+
+class NotFoundError(MicroserviceError):
+    """
+    "Not found" error.
+    JSON-RPC Error code: -32601 (using Method not found code)
+    """
+    def __init__(self, message: str = "Resource not found", data: Optional[Dict[str, Any]] = None):
+        super().__init__(message, code=-32601, data=data)
+
+
+class ConfigurationError(MicroserviceError):
+    """
+    Configuration error.
+    JSON-RPC Error code: -32603 (using Internal error code)
+    """
+    def __init__(self, message: str = "Configuration error", data: Optional[Dict[str, Any]] = None):
+        super().__init__(message, code=-32603, data=data)
+
+
+class AuthenticationError(MicroserviceError):
+    """
+    Authentication error.
+    JSON-RPC Error code: -32001 (server error)
+    """
+    def __init__(self, message: str = "Authentication error", data: Optional[Dict[str, Any]] = None):
+        super().__init__(message, code=-32001, data=data)
+
+
+class AuthorizationError(MicroserviceError):
+    """
+    Authorization error.
+    JSON-RPC Error code: -32002 (server error)
+    """
+    def __init__(self, message: str = "Authorization error", data: Optional[Dict[str, Any]] = None):
+        super().__init__(message, code=-32002, data=data)
+
+
+class TimeoutError(MicroserviceError):
+    """
+    Timeout error.
+    JSON-RPC Error code: -32003 (server error)
+    """
+    def __init__(self, message: str = "Timeout error", data: Optional[Dict[str, Any]] = None):
+        super().__init__(message, code=-32003, data=data)
+
+
+def format_validation_errors(errors: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    Formats validation errors into a standard format.
+
+    Args:
+        errors: List of validation errors.
+
+    Returns:
+        Formatted validation errors.
+    """
+    formatted_errors = {}
+    for error in errors:
+        loc = error.get("loc", [])
+        field = ".".join(str(item) for item in loc)
+        msg = error.get("msg", "Validation error")
+        formatted_errors[field] = msg
+    return formatted_errors

mcp_proxy_adapter/core/logging.py

@@ -0,0 +1,205 @@
+"""
+Module for configuring logging in the microservice.
+"""
+
+import logging
+import os
+import sys
+import uuid
+from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
+from typing import Dict, Optional, Any
+
+from mcp_proxy_adapter.config import config
+
+
+class CustomFormatter(logging.Formatter):
+    """
+    Custom formatter for logs with colored output in console.
+    """
+    grey = "\x1b[38;20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format_str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+    FORMATS = {
+        logging.DEBUG: grey + format_str + reset,
+        logging.INFO: grey + format_str + reset,
+        logging.WARNING: yellow + format_str + reset,
+        logging.ERROR: red + format_str + reset,
+        logging.CRITICAL: bold_red + format_str + reset
+    }
+
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+
+class RequestContextFilter(logging.Filter):
+    """
+    Filter for adding request context to logs.
+    """
+    
+    def __init__(self, request_id: Optional[str] = None):
+        super().__init__()
+        self.request_id = request_id
+    
+    def filter(self, record):
+        # Add request_id attribute to the record
+        record.request_id = self.request_id or "no-request-id"
+        return True
+
+
+class RequestLogger:
+    """
+    Logger class for logging requests with context.
+    """
+    
+    def __init__(self, logger_name: str, request_id: Optional[str] = None):
+        """
+        Initialize request logger.
+        
+        Args:
+            logger_name: Logger name.
+            request_id: Request identifier.
+        """
+        self.logger = logging.getLogger(logger_name)
+        self.request_id = request_id or str(uuid.uuid4())
+        self.filter = RequestContextFilter(self.request_id)
+        self.logger.addFilter(self.filter)
+    
+    def debug(self, msg: str, *args, **kwargs):
+        """Log message with DEBUG level."""
+        self.logger.debug(f"[{self.request_id}] {msg}", *args, **kwargs)
+    
+    def info(self, msg: str, *args, **kwargs):
+        """Log message with INFO level."""
+        self.logger.info(f"[{self.request_id}] {msg}", *args, **kwargs)
+    
+    def warning(self, msg: str, *args, **kwargs):
+        """Log message with WARNING level."""
+        self.logger.warning(f"[{self.request_id}] {msg}", *args, **kwargs)
+    
+    def error(self, msg: str, *args, **kwargs):
+        """Log message with ERROR level."""
+        self.logger.error(f"[{self.request_id}] {msg}", *args, **kwargs)
+    
+    def exception(self, msg: str, *args, **kwargs):
+        """Log exception with traceback."""
+        self.logger.exception(f"[{self.request_id}] {msg}", *args, **kwargs)
+    
+    def critical(self, msg: str, *args, **kwargs):
+        """Log message with CRITICAL level."""
+        self.logger.critical(f"[{self.request_id}] {msg}", *args, **kwargs)
+
+
+def setup_logging(
+    level: Optional[str] = None,
+    log_file: Optional[str] = None,
+    max_bytes: Optional[int] = None,
+    backup_count: Optional[int] = None,
+    rotation_type: Optional[str] = None,
+    rotation_when: Optional[str] = None,
+    rotation_interval: Optional[int] = None
+) -> logging.Logger:
+    """
+    Configure logging for the microservice.
+
+    Args:
+        level: Logging level. By default, taken from configuration.
+        log_file: Path to log file. By default, taken from configuration.
+        max_bytes: Maximum log file size in bytes. By default, taken from configuration.
+        backup_count: Number of rotation files. By default, taken from configuration.
+        rotation_type: Type of log rotation ('size' or 'time'). By default, taken from configuration.
+        rotation_when: Time unit for rotation (D, H, M, S). By default, taken from configuration.
+        rotation_interval: Interval for rotation. By default, taken from configuration.
+
+    Returns:
+        Configured logger.
+    """
+    # Get parameters from configuration if not explicitly specified
+    level = level or config.get("logging.level", "INFO")
+    log_file = log_file or config.get("logging.file")
+    rotation_type = rotation_type or config.get("logging.rotation.type", "size")
+    
+    # Size-based rotation parameters
+    max_bytes = max_bytes or config.get("logging.rotation.max_bytes", 10 * 1024 * 1024)  # 10 MB by default
+    backup_count = backup_count or config.get("logging.rotation.backup_count", 5)
+    
+    # Time-based rotation parameters
+    rotation_when = rotation_when or config.get("logging.rotation.when", "D")  # Daily by default
+    rotation_interval = rotation_interval or config.get("logging.rotation.interval", 1)
+
+    # Convert string logging level to constant
+    numeric_level = getattr(logging, level.upper(), None)
+    if not isinstance(numeric_level, int):
+        numeric_level = logging.INFO
+
+    # Create root logger
+    logger = logging.getLogger("mcp_proxy_adapter")
+    logger.setLevel(numeric_level)
+    logger.handlers = []  # Clear handlers in case of repeated call
+
+    # Create console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(numeric_level)
+    console_handler.setFormatter(CustomFormatter())
+    logger.addHandler(console_handler)
+
+    # Create file handler if file specified
+    if log_file:
+        # Create directory for log file if it doesn't exist
+        log_dir = os.path.dirname(log_file)
+        if log_dir and not os.path.exists(log_dir):
+            os.makedirs(log_dir, exist_ok=True)
+
+        # Choose rotation type
+        if rotation_type.lower() == "time":
+            file_handler = TimedRotatingFileHandler(
+                log_file,
+                when=rotation_when,
+                interval=rotation_interval,
+                backupCount=backup_count,
+                encoding="utf-8"
+            )
+        else:  # Default to size-based rotation
+            file_handler = RotatingFileHandler(
+                log_file,
+                maxBytes=max_bytes,
+                backupCount=backup_count,
+                encoding="utf-8"
+            )
+            
+        file_handler.setLevel(numeric_level)
+        file_formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        file_handler.setFormatter(file_formatter)
+        logger.addHandler(file_handler)
+
+    # Configure loggers for external libraries
+    log_levels = config.get("logging.levels", {})
+    for logger_name, logger_level in log_levels.items():
+        lib_logger = logging.getLogger(logger_name)
+        lib_logger.setLevel(getattr(logging, logger_level.upper(), logging.INFO))
+
+    return logger
+
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger with the specified name.
+    
+    Args:
+        name: Logger name.
+        
+    Returns:
+        Configured logger instance.
+    """
+    return logging.getLogger(name)
+
+
+# Global logger for use throughout the application
+logger = setup_logging()