mcp-proxy-adapter 2.1.17__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

@@ -0,0 +1,195 @@
+"""
+Module for microservice configuration management.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+class Config:
+    """
+    Configuration management class for the microservice.
+    Allows loading settings from configuration file and environment variables.
+    """
+
+    def __init__(self, config_path: Optional[str] = None):
+        """
+        Initialize configuration.
+
+        Args:
+            config_path: Path to configuration file. If not specified, "./config.json" is used.
+        """
+        self.config_path = config_path or "./config.json"
+        self.config_data: Dict[str, Any] = {}
+        self.load_config()
+
+    def load_config(self) -> None:
+        """
+        Load configuration from file and environment variables.
+        """
+        # Set default config values
+        self.config_data = {
+            "server": {
+                "host": "0.0.0.0",
+                "port": 8000,
+                "debug": False,
+                "log_level": "INFO"
+            },
+            "logging": {
+                "level": "INFO",
+                "file": None
+            }
+        }
+        
+        # Try to load configuration from file
+        if os.path.exists(self.config_path):
+            try:
+                with open(self.config_path, 'r', encoding='utf-8') as f:
+                    file_config = json.load(f)
+                    self._update_nested_dict(self.config_data, file_config)
+            except Exception as e:
+                print(f"Error loading config from {self.config_path}: {e}")
+        
+        # Load configuration from environment variables
+        self._load_env_variables()
+
+    def load_from_file(self, config_path: str) -> None:
+        """
+        Load configuration from the specified file.
+
+        Args:
+            config_path: Path to configuration file.
+        """
+        self.config_path = config_path
+        self.load_config()
+
+    def _load_env_variables(self) -> None:
+        """
+        Load configuration from environment variables.
+        Environment variables should be in format SERVICE_SECTION_KEY=value.
+        For example, SERVICE_SERVER_PORT=8080.
+        """
+        prefix = "SERVICE_"
+        for key, value in os.environ.items():
+            if key.startswith(prefix):
+                parts = key[len(prefix):].lower().split("_", 1)
+                if len(parts) == 2:
+                    section, param = parts
+                    if section not in self.config_data:
+                        self.config_data[section] = {}
+                    self.config_data[section][param] = self._convert_env_value(value)
+
+    def _convert_env_value(self, value: str) -> Any:
+        """
+        Convert environment variable value to appropriate type.
+
+        Args:
+            value: Value as string
+
+        Returns:
+            Converted value
+        """
+        # Try to convert to appropriate type
+        if value.lower() == "true":
+            return True
+        elif value.lower() == "false":
+            return False
+        elif value.isdigit():
+            return int(value)
+        else:
+            try:
+                return float(value)
+            except ValueError:
+                return value
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get configuration value for key.
+
+        Args:
+            key: Configuration key in format "section.param"
+            default: Default value if key not found
+
+        Returns:
+            Configuration value
+        """
+        parts = key.split(".")
+        
+        # Get value from config
+        value = self.config_data
+        for part in parts:
+            if not isinstance(value, dict) or part not in value:
+                return default
+            value = value[part]
+            
+        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.
+
+        Args:
+            key: Configuration key in format "section.param"
+            value: Configuration value
+        """
+        parts = key.split(".")
+        if len(parts) == 1:
+            self.config_data[key] = value
+        else:
+            section = parts[0]
+            param = ".".join(parts[1:])
+            
+            if section not in self.config_data:
+                self.config_data[section] = {}
+                
+            current = self.config_data[section]
+            for part in parts[1:-1]:
+                if part not in current:
+                    current[part] = {}
+                current = current[part]
+                
+            current[parts[-1]] = value
+
+    def save(self, path: Optional[str] = None) -> None:
+        """
+        Save configuration to file.
+
+        Args:
+            path: Path to configuration file. If not specified, self.config_path is used.
+        """
+        save_path = path or self.config_path
+        with open(save_path, 'w', encoding='utf-8') as f:
+            json.dump(self.config_data, f, indent=2)
+
+    def _update_nested_dict(self, d: Dict, u: Dict) -> Dict:
+        """
+        Update nested dictionary recursively.
+
+        Args:
+            d: Dictionary to update
+            u: Dictionary with new values
+
+        Returns:
+            Updated dictionary
+        """
+        for k, v in u.items():
+            if isinstance(v, dict) and k in d and isinstance(d[k], dict):
+                self._update_nested_dict(d[k], v)
+            else:
+                d[k] = v
+        return d
+
+
+# Singleton instance
+config = Config()

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