mcp-proxy-adapter 1.0.0__py3-none-any.whl

adapters/__init__.py

@@ -0,0 +1,16 @@
+"""
+Адаптеры Command Registry
+========================
+
+Адаптеры обеспечивают интеграцию Command Registry с различными протоколами и системами.
+Они преобразуют команды из реестра в формат, понятный другим системам.
+
+Доступные адаптеры:
+- RESTAdapter: Создает REST API эндпоинты
+- MCPProxyAdapter: Интегрирует с MCPProxy для работы с инструментами моделей ИИ
+"""
+
+from command_registry.adapters.rest_adapter import RESTAdapter
+from ..adapter import MCPProxyAdapter  # Импортируем из основного модуля adapter.py
+
+__all__ = ['RESTAdapter', 'MCPProxyAdapter'] 

analyzers/__init__.py

@@ -0,0 +1,14 @@
+"""
+Analyzers for extracting metadata from functions and docstrings.
+
+This module contains classes for analyzing type annotations and docstrings
+of Python functions to automatically extract metadata for commands.
+"""
+
+from .type_analyzer import TypeAnalyzer
+from .docstring_analyzer import DocstringAnalyzer
+
+__all__ = [
+    'TypeAnalyzer',
+    'DocstringAnalyzer',
+] 

analyzers/docstring_analyzer.py

@@ -0,0 +1,199 @@
+"""
+Docstring analyzer for extracting information from function documentation.
+"""
+import inspect
+from typing import Dict, Any, Optional, Callable, List, Tuple
+import docstring_parser
+
+class DocstringAnalyzer:
+    """
+    Docstring analyzer for extracting metadata from function documentation.
+    
+    This class is responsible for analyzing command handler function docstrings
+    and extracting function descriptions, parameters, and return values.
+    """
+    
+    def analyze(self, handler: Callable) -> Dict[str, Any]:
+        """
+        Analyzes function docstring and returns metadata.
+        
+        Args:
+            handler: Handler function to analyze
+            
+        Returns:
+            Dict[str, Any]: Metadata extracted from docstring
+        """
+        result = {
+            "description": "",
+            "summary": "",
+            "parameters": {},
+            "returns": {
+                "description": ""
+            }
+        }
+        
+        # Get function signature
+        sig = inspect.signature(handler)
+        
+        # Get docstring
+        docstring = handler.__doc__ or ""
+        
+        # Parse docstring
+        try:
+            parsed_doc = docstring_parser.parse(docstring)
+            
+            # Extract general function description
+            if parsed_doc.short_description:
+                result["summary"] = parsed_doc.short_description
+                result["description"] = parsed_doc.short_description
+                
+            if parsed_doc.long_description:
+                # If both short and long descriptions exist, combine them
+                if result["description"]:
+                    result["description"] = f"{result['description']}\n\n{parsed_doc.long_description}"
+                else:
+                    result["description"] = parsed_doc.long_description
+            
+            # Extract parameter information
+            for param in parsed_doc.params:
+                param_name = param.arg_name
+                param_desc = param.description or f"Parameter {param_name}"
+                param_type = None
+                
+                # If parameter type is specified in docstring, use it
+                if param.type_name:
+                    param_type = self._parse_type_from_docstring(param.type_name)
+                
+                # Add parameter to metadata
+                if param_name not in result["parameters"]:
+                    result["parameters"][param_name] = {}
+                    
+                result["parameters"][param_name]["description"] = param_desc
+                
+                if param_type:
+                    result["parameters"][param_name]["type"] = param_type
+            
+            # Extract return value information
+            if parsed_doc.returns:
+                result["returns"]["description"] = parsed_doc.returns.description or "Return value"
+                
+                if parsed_doc.returns.type_name:
+                    result["returns"]["type"] = self._parse_type_from_docstring(parsed_doc.returns.type_name)
+        
+        except Exception as e:
+            # In case of parsing error, use docstring as is
+            if docstring:
+                result["description"] = docstring.strip()
+        
+        # Fill parameter information from signature if not found in docstring
+        for param_name, param in sig.parameters.items():
+            # Skip self for methods
+            if param_name == 'self':
+                continue
+                
+            # If parameter not yet added to metadata, add it
+            if param_name not in result["parameters"]:
+                result["parameters"][param_name] = {
+                    "description": f"Parameter {param_name}"
+                }
+            
+            # Determine if parameter is required
+            required = param.default == inspect.Parameter.empty
+            result["parameters"][param_name]["required"] = required
+            
+            # Add default value if exists
+            if param.default != inspect.Parameter.empty:
+                # Some default values cannot be serialized to JSON
+                # So we check if the value can be serialized
+                if param.default is None or isinstance(param.default, (str, int, float, bool, list, dict)):
+                    result["parameters"][param_name]["default"] = param.default
+        
+        return result
+    
+    def validate(self, handler: Callable) -> Tuple[bool, List[str]]:
+        """
+        Validates that function docstring matches its formal parameters.
+        
+        Args:
+            handler: Command handler function
+            
+        Returns:
+            Tuple[bool, List[str]]: Validity flag and list of errors
+        """
+        errors = []
+        
+        # Get function formal parameters
+        sig = inspect.signature(handler)
+        formal_params = list(sig.parameters.keys())
+        
+        # Skip self parameter for methods
+        if formal_params and formal_params[0] == 'self':
+            formal_params = formal_params[1:]
+            
+        # Parse docstring
+        docstring = handler.__doc__ or ""
+        parsed_doc = docstring_parser.parse(docstring)
+        
+        # Check for function description
+        if not parsed_doc.short_description and not parsed_doc.long_description:
+            errors.append(f"Missing function description")
+        
+        # Get parameters from docstring
+        doc_params = {param.arg_name: param for param in parsed_doc.params}
+        
+        # Check that all formal parameters are described in docstring
+        for param in formal_params:
+            if param not in doc_params and param != 'params':  # 'params' is special case, can be dictionary of all parameters
+                errors.append(f"Parameter '{param}' not described in function docstring")
+        
+        # Check for returns in docstring
+        if not parsed_doc.returns and not any(t.type_name == 'Returns' for t in parsed_doc.meta):
+            errors.append(f"Missing return value description in function docstring")
+        
+        return len(errors) == 0, errors
+    
+    def _parse_type_from_docstring(self, type_str: str) -> str:
+        """
+        Parses type from string representation in docstring.
+        
+        Args:
+            type_str: String representation of type
+            
+        Returns:
+            str: Type in OpenAPI format
+        """
+        # Simple mapping of string types to OpenAPI types
+        type_map = {
+            "str": "string",
+            "string": "string",
+            "int": "integer",
+            "integer": "integer",
+            "float": "number",
+            "number": "number",
+            "bool": "boolean",
+            "boolean": "boolean",
+            "list": "array",
+            "array": "array",
+            "dict": "object",
+            "object": "object",
+            "none": "null",
+            "null": "null",
+        }
+        
+        # Convert to lowercase and remove spaces
+        cleaned_type = type_str.lower().strip()
+        
+        # Check for simple types
+        if cleaned_type in type_map:
+            return type_map[cleaned_type]
+        
+        # Check for List[X]
+        if cleaned_type.startswith("list[") or cleaned_type.startswith("array["):
+            return "array"
+        
+        # Check for Dict[X, Y]
+        if cleaned_type.startswith("dict[") or cleaned_type.startswith("object["):
+            return "object"
+        
+        # Default to object
+        return "object" 

analyzers/type_analyzer.py

@@ -0,0 +1,151 @@
+"""
+Type analyzer for extracting information from function type annotations.
+"""
+import inspect
+from typing import Dict, Any, List, Optional, Callable, Union, get_origin, get_args, get_type_hints
+
+class TypeAnalyzer:
+    """
+    Type analyzer for extracting information from function type annotations.
+    
+    This class is responsible for analyzing type annotations of command handler functions
+    and converting them to JSON Schema/OpenAPI type format.
+    """
+    
+    def __init__(self):
+        # Mapping Python types to OpenAPI types
+        self.type_map = {
+            str: "string",
+            int: "integer",
+            float: "number",
+            bool: "boolean",
+            list: "array",
+            dict: "object",
+            Any: "object",
+            None: "null",
+        }
+    
+    def analyze(self, handler: Callable) -> Dict[str, Any]:
+        """
+        Analyzes function type annotations and returns metadata.
+        
+        Args:
+            handler: Handler function to analyze
+            
+        Returns:
+            Dict[str, Any]: Metadata about parameter types and return value
+        """
+        result = {
+            "parameters": {},
+            "returns": None
+        }
+        
+        # Get function signature
+        sig = inspect.signature(handler)
+        
+        # Get type annotations
+        type_hints = self._get_type_hints(handler)
+        
+        # Analyze parameters
+        for param_name, param in sig.parameters.items():
+            # Skip self for methods
+            if param_name == 'self':
+                continue
+                
+            # If parameter is named params, assume it's a dictionary of all parameters
+            if param_name == 'params':
+                continue
+                
+            # Determine if parameter is required
+            required = param.default == inspect.Parameter.empty
+            
+            # Determine parameter type
+            param_type = "object"  # Default type
+            
+            if param_name in type_hints:
+                param_type = self._map_type_to_openapi(type_hints[param_name])
+                
+            # Create parameter metadata
+            param_metadata = {
+                "type": param_type,
+                "required": required
+            }
+            
+            # Add default value if exists
+            if param.default != inspect.Parameter.empty:
+                # Some default values cannot be serialized to JSON
+                # So we convert them to string representation for such cases
+                if param.default is None or isinstance(param.default, (str, int, float, bool, list, dict)):
+                    param_metadata["default"] = param.default
+            
+            # Add parameter to metadata
+            result["parameters"][param_name] = param_metadata
+        
+        # Analyze return value
+        if 'return' in type_hints:
+            result["returns"] = self._map_type_to_openapi(type_hints['return'])
+        
+        return result
+    
+    def _get_type_hints(self, handler: Callable) -> Dict[str, Any]:
+        """
+        Gets type annotations of a function.
+        
+        Args:
+            handler: Handler function
+            
+        Returns:
+            Dict[str, Any]: Type annotations
+        """
+        try:
+            return get_type_hints(handler)
+        except Exception:
+            # If failed to get annotations via get_type_hints,
+            # extract them manually from __annotations__
+            return getattr(handler, "__annotations__", {})
+    
+    def _map_type_to_openapi(self, type_hint: Any) -> Union[str, Dict[str, Any]]:
+        """
+        Converts Python type to OpenAPI type.
+        
+        Args:
+            type_hint: Python type
+            
+        Returns:
+            Union[str, Dict[str, Any]]: OpenAPI type string representation or schema
+        """
+        # Check for None
+        if type_hint is None:
+            return "null"
+        
+        # Handle primitive types
+        if type_hint in self.type_map:
+            return self.type_map[type_hint]
+        
+        # Check for generic types
+        origin = get_origin(type_hint)
+        if origin is not None:
+            # Handle List[X], Dict[X, Y], etc.
+            if origin in (list, List):
+                args = get_args(type_hint)
+                if args:
+                    item_type = self._map_type_to_openapi(args[0])
+                    return {
+                        "type": "array",
+                        "items": item_type if isinstance(item_type, dict) else {"type": item_type}
+                    }
+                return "array"
+            elif origin in (dict, Dict):
+                # For dict we just return object, as OpenAPI
+                # doesn't have a direct equivalent for Dict[X, Y]
+                return "object"
+            elif origin is Union:
+                # For Union we take the first type that is not None
+                args = get_args(type_hint)
+                for arg in args:
+                    if arg is not type(None):
+                        return self._map_type_to_openapi(arg)
+                return "object"
+        
+        # Default to object
+        return "object" 

cli/__init__.py

@@ -0,0 +1,12 @@
+"""
+Командный интерфейс для запуска команд из командной строки.
+
+Этот модуль предоставляет инструменты для создания командной строки
+на основе зарегистрированных команд.
+"""
+
+from command_registry.cli.command_runner import CommandRunner
+
+__all__ = [
+    'CommandRunner',
+] 

cli/__main__.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+"""
+Entry point for the command registry CLI interface.
+
+This module allows running commands from the command line
+using the command dispatcher.
+
+Usage:
+    python -m command_registry.cli [command] [args...]
+"""
+
+import os
+import sys
+import importlib.util
+from typing import Optional
+
+from command_registry.cli.command_runner import CommandRunner
+from command_registry.dispatchers.base_dispatcher import BaseDispatcher
+from command_registry.dispatchers.command_dispatcher import CommandDispatcher
+
+
+def find_dispatcher() -> BaseDispatcher:
+    """
+    Finds and creates command dispatcher.
+    
+    Search order:
+    1. Checks DISPATCHER_MODULE environment variable
+    2. Looks for app.py in current directory
+    3. Creates new CommandDispatcher
+    
+    Returns:
+        BaseDispatcher: Command dispatcher
+    """
+    # Check environment variable
+    dispatcher_module = os.environ.get("DISPATCHER_MODULE")
+    if dispatcher_module:
+        try:
+            module_path, attr_name = dispatcher_module.rsplit(":", 1)
+            module = importlib.import_module(module_path)
+            return getattr(module, attr_name)
+        except (ValueError, ImportError, AttributeError) as e:
+            print(f"Failed to load dispatcher from {dispatcher_module}: {e}", 
+                  file=sys.stderr)
+    
+    # Check app.py file
+    app_path = os.path.join(os.getcwd(), "app.py")
+    if os.path.exists(app_path):
+        try:
+            spec = importlib.util.spec_from_file_location("app", app_path)
+            if spec and spec.loader:
+                app = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(app)
+                
+                # Look for dispatcher in module
+                dispatcher = getattr(app, "dispatcher", None)
+                if dispatcher and isinstance(dispatcher, BaseDispatcher):
+                    return dispatcher
+        except Exception as e:
+            print(f"Failed to load dispatcher from app.py: {e}", 
+                  file=sys.stderr)
+    
+    # Create new dispatcher if not found
+    return CommandDispatcher()
+
+
+def main() -> None:
+    """
+    Main function for running CLI interface.
+    """
+    # Get dispatcher
+    dispatcher = find_dispatcher()
+    
+    # Create and run CommandRunner
+    runner = CommandRunner(dispatcher)
+    runner.run(sys.argv[1:])
+
+
+if __name__ == "__main__":
+    main()