mcp-proxy-adapter 6.3.3__py3-none-any.whl → 6.3.5__py3-none-any.whl

mcp_proxy_adapter/commands/load_command.py

@@ -13,11 +13,18 @@ class LoadResult(SuccessResult):
     """
     Result of the load command execution.
     """
-    
-    def __init__(self, success: bool, commands_loaded: int, loaded_commands: list, source: str, error: Optional[str] = None):
+
+    def __init__(
+        self,
+        success: bool,
+        commands_loaded: int,
+        loaded_commands: list,
+        source: str,
+        error: Optional[str] = None,
+    ):
         """
         Initialize load command result.
-        
+
         Args:
             success: Whether loading was successful
             commands_loaded: Number of commands loaded
@@ -29,22 +36,22 @@ class LoadResult(SuccessResult):
             "success": success,
             "commands_loaded": commands_loaded,
             "loaded_commands": loaded_commands,
-            "source": source
+            "source": source,
         }
         if error:
             data["error"] = error
-            
+
         message = f"Loaded {commands_loaded} commands from {source}"
         if error:
             message = f"Failed to load commands from {source}: {error}"
-            
+
         super().__init__(data=data, message=message)
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """
         Get JSON schema for result validation.
-        
+
         Returns:
             Dict[str, Any]: JSON schema
         """
@@ -58,74 +65,79 @@ class LoadResult(SuccessResult):
                         "commands_loaded": {"type": "integer"},
                         "loaded_commands": {
                             "type": "array",
-                            "items": {"type": "string"}
+                            "items": {"type": "string"},
                         },
                         "source": {"type": "string"},
-                        "error": {"type": "string"}
+                        "error": {"type": "string"},
                     },
-                    "required": ["success", "commands_loaded", "loaded_commands", "source"]
+                    "required": [
+                        "success",
+                        "commands_loaded",
+                        "loaded_commands",
+                        "source",
+                    ],
                 }
             },
-            "required": ["data"]
+            "required": ["data"],
         }
 
 
 class LoadCommand(Command):
     """
     Command that loads commands from local path or URL.
-    
+
     This command allows dynamic loading of command modules from either local file system
     or remote HTTP/HTTPS URLs. The command automatically detects whether the source
     is a local path or URL and handles the loading accordingly.
-    
+
     For local paths, the command loads Python modules ending with '_command.py'.
     For URLs, the command downloads the Python code and loads it as a temporary module.
-    
+
     The loaded commands are registered in the command registry and become immediately
     available for execution. Only commands that inherit from the base Command class
     and are properly structured will be loaded and registered.
-    
+
     Security considerations:
     - Local paths are validated for existence and proper naming
     - URLs are downloaded with timeout protection
     - Temporary files are automatically cleaned up after loading
     - Only files ending with '_command.py' are accepted
-    
+
     Examples:
     - Load from local file: "./my_command.py"
     - Load from URL: "https://example.com/remote_command.py"
     """
-    
+
     name = "load"
     result_class = LoadResult
-    
+
     async def execute(self, source: str, **kwargs) -> LoadResult:
         """
         Execute load command.
-        
+
         Args:
             source: Source path or URL to load command from
             **kwargs: Additional parameters
-            
+
         Returns:
             LoadResult: Load command result
         """
         # Load command from source
         result = registry.load_command_from_source(source)
-        
+
         return LoadResult(
             success=result.get("success", False),
             commands_loaded=result.get("commands_loaded", 0),
             loaded_commands=result.get("loaded_commands", []),
             source=result.get("source", source),
-            error=result.get("error")
+            error=result.get("error"),
         )
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """
         Get JSON schema for command parameters.
-        
+
         Returns:
             Dict[str, Any]: JSON schema
         """
@@ -137,21 +149,23 @@ class LoadCommand(Command):
                     "description": "Source path or URL to load command from (must end with '_command.py')",
                     "examples": [
                         "./my_command.py",
-                        "https://example.com/remote_command.py"
-                    ]
+                        "https://example.com/remote_command.py",
+                    ],
                 }
             },
-            "required": ["source"]
+            "required": ["source"],
         }
-    
+
     @classmethod
-    def _generate_examples(cls, params: Dict[str, Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def _generate_examples(
+        cls, params: Dict[str, Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
         """
         Generate custom examples for load command.
-        
+
         Args:
             params: Information about command parameters
-            
+
         Returns:
             List of examples
         """
@@ -159,18 +173,22 @@ class LoadCommand(Command):
             {
                 "command": cls.name,
                 "params": {"source": "./custom_command.py"},
-                "description": "Load a command from local file system"
+                "description": "Load a command from local file system",
             },
             {
                 "command": cls.name,
-                "params": {"source": "https://raw.githubusercontent.com/user/repo/main/remote_command.py"},
-                "description": "Load a command from GitHub raw content"
+                "params": {
+                    "source": "https://raw.githubusercontent.com/user/repo/main/remote_command.py"
+                },
+                "description": "Load a command from GitHub raw content",
             },
             {
                 "command": cls.name,
-                "params": {"source": "https://example.com/api/commands/test_command.py"},
-                "description": "Load a command from remote API endpoint"
-            }
+                "params": {
+                    "source": "https://example.com/api/commands/test_command.py"
+                },
+                "description": "Load a command from remote API endpoint",
+            },
         ]
-        
-        return examples 
+
+        return examples

mcp_proxy_adapter/commands/plugins_command.py

@@ -14,11 +14,18 @@ class PluginsResult(SuccessResult):
     """
     Result of the plugins command execution.
     """
-    
-    def __init__(self, success: bool, plugins_server: str, plugins: list, total_plugins: int, error: Optional[str] = None):
+
+    def __init__(
+        self,
+        success: bool,
+        plugins_server: str,
+        plugins: list,
+        total_plugins: int,
+        error: Optional[str] = None,
+    ):
         """
         Initialize plugins command result.
-        
+
         Args:
             success: Whether operation was successful
             plugins_server: URL of the plugins server
@@ -30,22 +37,22 @@ class PluginsResult(SuccessResult):
             "success": success,
             "plugins_server": plugins_server,
             "plugins": plugins,
-            "total_plugins": total_plugins
+            "total_plugins": total_plugins,
         }
         if error:
             data["error"] = error
-            
+
         message = f"Found {total_plugins} plugins from {plugins_server}"
         if error:
             message = f"Failed to load plugins from {plugins_server}: {error}"
-            
+
         super().__init__(data=data, message=message)
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """
         Get JSON schema for result validation.
-        
+
         Returns:
             Dict[str, Any]: JSON schema
         """
@@ -66,32 +73,37 @@ class PluginsResult(SuccessResult):
                                     "description": {"type": "string"},
                                     "url": {"type": "string"},
                                     "version": {"type": "string"},
-                                    "author": {"type": "string"}
-                                }
-                            }
+                                    "author": {"type": "string"},
+                                },
+                            },
                         },
                         "total_plugins": {"type": "integer"},
-                        "error": {"type": "string"}
+                        "error": {"type": "string"},
                     },
-                    "required": ["success", "plugins_server", "plugins", "total_plugins"]
+                    "required": [
+                        "success",
+                        "plugins_server",
+                        "plugins",
+                        "total_plugins",
+                    ],
                 }
             },
-            "required": ["data"]
+            "required": ["data"],
         }
 
 
 class PluginsCommand(Command):
     """
     Command that reads and displays available plugins from a plugins server.
-    
+
     This command fetches a JSON file from a configured plugins server URL that contains
     a list of available plugins. Each plugin in the list typically contains metadata
     such as name, description, URL, version, and author information.
-    
+
     The plugins server URL is configured in the system configuration under
     'commands.plugins_server'. The JSON file should contain an array of plugin objects
     with the following structure:
-    
+
     {
         "plugins": [
             {
@@ -103,43 +115,43 @@ class PluginsCommand(Command):
             }
         ]
     }
-    
+
     This command is useful for:
     - Discovering available plugins without manually browsing the server
     - Getting metadata about plugins before loading them
     - Building plugin management interfaces
     - Checking plugin availability and versions
-    
+
     The command will return the list of all available plugins along with their
     metadata, making it easy to choose which plugins to load.
     """
-    
+
     name = "plugins"
     result_class = PluginsResult
-    
+
     async def execute(self, **kwargs) -> PluginsResult:
         """
         Execute plugins command.
-        
+
         Args:
             **kwargs: Additional parameters
-            
+
         Returns:
             PluginsResult: Plugins command result
         """
         try:
             # Get configuration from the global config instance
             plugins_server_url = config_instance.get("commands.plugins_server")
-            
+
             if not plugins_server_url:
                 return PluginsResult(
                     success=False,
                     plugins_server="",
                     plugins=[],
                     total_plugins=0,
-                    error="Plugins server URL not configured"
+                    error="Plugins server URL not configured",
                 )
-            
+
             # Import requests if available
             try:
                 import requests
@@ -149,16 +161,16 @@ class PluginsCommand(Command):
                     plugins_server=plugins_server_url,
                     plugins=[],
                     total_plugins=0,
-                    error="requests library not available"
+                    error="requests library not available",
                 )
-            
+
             # Fetch plugins list
             response = requests.get(plugins_server_url, timeout=30)
             response.raise_for_status()
-            
+
             # Parse JSON response
             plugins_data = response.json()
-            
+
             # Handle different JSON formats
             if isinstance(plugins_data, list):
                 # Direct array format
@@ -168,42 +180,48 @@ class PluginsCommand(Command):
                 plugins_list = plugins_data.get("plugins", [])
             elif "plugin" in plugins_data:
                 # Single plugin format (like from plugins.techsup.od.ua/)
-                plugins_list = [{
-                    "name": plugins_data.get("plugin", "").replace(".py", ""),
-                    "description": plugins_data.get("descr", ""),
-                    "url": f"{plugins_server_url.rstrip('/')}/{plugins_data.get('plugin', '')}",
-                    "version": "1.0.0",
-                    "author": "Unknown",
-                    "category": plugins_data.get("category", "")
-                }]
+                plugins_list = [
+                    {
+                        "name": plugins_data.get("plugin", "").replace(".py", ""),
+                        "description": plugins_data.get("descr", ""),
+                        "url": f"{plugins_server_url.rstrip('/')}/{plugins_data.get('plugin', '')}",
+                        "version": "1.0.0",
+                        "author": "Unknown",
+                        "category": plugins_data.get("category", ""),
+                    }
+                ]
             else:
                 # Unknown format, try to extract any plugin-like data
                 plugins_list = []
                 for key, value in plugins_data.items():
-                    if isinstance(value, dict) and any(k in value for k in ["name", "plugin", "url"]):
+                    if isinstance(value, dict) and any(
+                        k in value for k in ["name", "plugin", "url"]
+                    ):
                         plugins_list.append(value)
-            
+
             return PluginsResult(
                 success=True,
                 plugins_server=plugins_server_url,
                 plugins=plugins_list,
-                total_plugins=len(plugins_list)
+                total_plugins=len(plugins_list),
             )
-            
+
         except Exception as e:
             return PluginsResult(
                 success=False,
-                plugins_server=plugins_server_url if 'plugins_server_url' in locals() else "",
+                plugins_server=(
+                    plugins_server_url if "plugins_server_url" in locals() else ""
+                ),
                 plugins=[],
                 total_plugins=0,
-                error=str(e)
+                error=str(e),
             )
-    
+
     @classmethod
     def get_metadata(cls) -> Dict[str, Any]:
         """
         Get command metadata.
-        
+
         Returns:
             Dict[str, Any]: Command metadata
         """
@@ -213,23 +231,31 @@ class PluginsCommand(Command):
             "description": cls.__doc__,
             "parameters": {},
             "examples": cls._generate_examples({}),
-            "schema": cls.result_class.get_schema()
+            "schema": cls.result_class.get_schema(),
         }
-    
+
     @classmethod
-    def _generate_examples(cls, params: Dict[str, Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def _generate_examples(
+        cls, params: Dict[str, Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
         """
         Generate examples for the command.
-        
+
         Args:
             params: Command parameters schema
-            
+
         Returns:
             List[Dict[str, Any]]: List of examples
         """
         examples = [
-            {"command": cls.name, "description": "Get list of available plugins from configured server"},
+            {
+                "command": cls.name,
+                "description": "Get list of available plugins from configured server",
+            },
             {"command": cls.name, "description": "Discover plugins without parameters"},
-            {"command": cls.name, "description": "Check plugin availability and metadata"}
+            {
+                "command": cls.name,
+                "description": "Check plugin availability and metadata",
+            },
         ]
-        return examples 
+        return examples