mcli-framework 7.12.2__py3-none-any.whl → 7.12.4__py3-none-any.whl

mcli/lib/api/api.py

@@ -1,20 +1,15 @@
 import functools
 import inspect
-import json
 import os
 import random
 import socket
-import sys
 import threading
 import time
-from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Union
 
-import click
-import requests
 import uvicorn
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 
@@ -228,7 +223,7 @@ class ClickToAPIDecorator:
         fields = {}
 
         for param_name, param in sig.parameters.items():
-            if param_name in ["self", "ctx"]:
+            if param_name in ["sel", "ctx"]:
                 continue
 
             # Get parameter type and default
@@ -243,7 +238,7 @@ class ClickToAPIDecorator:
                 # Handle boolean flags
                 param_type = bool
             elif param_type in [int, float]:
-                param_type = param_type
+                param_type = param_type  # noqa: SIM909
             else:
                 param_type = str
 
@@ -544,7 +539,7 @@ def register_command_as_api(
         logger.debug("API app not available, skipping endpoint registration")
         return
 
-    logger.info(f"API app available, proceeding with registration")
+    logger.info("API app available, proceeding with registration")
 
     decorator = ClickToAPIDecorator(
         endpoint_path=endpoint_path,

mcli/lib/api/daemon_client.py

@@ -1,4 +1,3 @@
-import json
 import time
 from dataclasses import dataclass
 from pathlib import Path
@@ -14,7 +13,7 @@ logger = get_logger(__name__)
 
 @dataclass
 class DaemonClientConfig:
-    """Configuration for daemon client"""
+    """Configuration for daemon client."""
 
     host: str = "localhost"
     port: int = 8000
@@ -24,7 +23,7 @@ class DaemonClientConfig:
 
 
 class APIDaemonClient:
-    """Client for interacting with the MCLI API Daemon or Flask shell daemon"""
+    """Client for interacting with the MCLI API Daemon or Flask shell daemon."""
 
     def __init__(self, config: Optional[DaemonClientConfig] = None, shell_mode: bool = False):
         self.config = config or self._load_config()
@@ -37,8 +36,8 @@ class APIDaemonClient:
         self.session = requests.Session()
 
     def execute_shell_command(self, command: str) -> Dict[str, Any]:
-        """Execute a raw shell command via the Flask test server"""
-        url = f"http://localhost:5005/execute"
+        """Execute a raw shell command via the Flask test server."""
+        url = "http://localhost:5005/execute"
         try:
             response = self.session.post(
                 url, json={"command": command}, timeout=self.config.timeout
@@ -49,7 +48,7 @@ class APIDaemonClient:
             raise Exception(f"Failed to connect to Flask shell daemon at {url}: {e}")
 
     def _load_config(self) -> DaemonClientConfig:
-        """Load configuration from config files"""
+        """Load configuration from config files."""
         config = DaemonClientConfig()
 
         # Try to load from config.toml files
@@ -83,7 +82,7 @@ class APIDaemonClient:
         params: Optional[Dict] = None,
         **kwargs,
     ) -> Dict[str, Any]:
-        """Make HTTP request to daemon with retry logic"""
+        """Make HTTP request to daemon with retry logic."""
         url = f"{self.base_url}{endpoint}"
         for attempt in range(self.config.retry_attempts):
             try:
@@ -107,11 +106,11 @@ class APIDaemonClient:
         return {}  # Always return a dict
 
     def health_check(self) -> Dict[str, Any]:
-        """Check daemon health"""
+        """Check daemon health."""
         return self._make_request("GET", "/health")
 
     def status(self) -> Dict[str, Any]:
-        """Get daemon status"""
+        """Get daemon status."""
         return self._make_request("GET", "/status")
 
     def list_commands(self, all: bool = False) -> Dict[str, Any]:
@@ -120,7 +119,7 @@ class APIDaemonClient:
         return self._make_request("GET", "/commands", params=params)
 
     def get_command_details(self, command_id: str) -> Optional[Dict[str, Any]]:
-        """Get detailed information about a specific command"""
+        """Get detailed information about a specific command."""
         return self._make_request("GET", f"/commands/{command_id}")
 
     def execute_command(
@@ -130,7 +129,7 @@ class APIDaemonClient:
         args: Optional[List[str]] = None,
         timeout: Optional[int] = None,
     ) -> Dict[str, Any]:
-        """Execute a command via the daemon"""
+        """Execute a command via the daemon."""
         if not command_id and not command_name:
             raise ValueError("Either command_id or command_name must be provided")
 
@@ -146,15 +145,15 @@ class APIDaemonClient:
         return self._make_request("POST", "/execute", data=data)
 
     def start_daemon(self) -> Dict[str, Any]:
-        """Start the daemon via HTTP"""
+        """Start the daemon via HTTP."""
         return self._make_request("POST", "/daemon/start")
 
     def stop_daemon(self) -> Dict[str, Any]:
-        """Stop the daemon via HTTP"""
+        """Stop the daemon via HTTP."""
         return self._make_request("POST", "/daemon/stop")
 
     def is_running(self) -> bool:
-        """Check if daemon is running"""
+        """Check if daemon is running."""
         try:
             status = self.status()
             return status.get("running", False)
@@ -162,7 +161,7 @@ class APIDaemonClient:
             return False
 
     def wait_for_daemon(self, timeout: int = 30) -> bool:
-        """Wait for daemon to be ready"""
+        """Wait for daemon to be ready."""
         start_time = time.time()
         while time.time() - start_time < timeout:
             if self.is_running():
@@ -173,31 +172,31 @@ class APIDaemonClient:
 
 # Convenience functions for easy usage
 def execute_shell_command_via_flask(command: str) -> Dict[str, Any]:
-    """Execute a raw shell command via the Flask test server (convenience function)"""
+    """Execute a raw shell command via the Flask test server (convenience function)."""
     client = APIDaemonClient(shell_mode=True)
     return client.execute_shell_command(command)
 
 
 def get_daemon_client() -> APIDaemonClient:
-    """Get a configured daemon client"""
+    """Get a configured daemon client."""
     return APIDaemonClient()
 
 
 def execute_command_via_daemon(
     command_name: str, args: Optional[List[str]] = None
 ) -> Dict[str, Any]:
-    """Execute a command via the daemon (convenience function)"""
+    """Execute a command via the daemon (convenience function)."""
     client = get_daemon_client()
     return client.execute_command(command_name=command_name, args=args)
 
 
 def check_daemon_status() -> Dict[str, Any]:
-    """Check daemon status (convenience function)"""
+    """Check daemon status (convenience function)."""
     client = get_daemon_client()
     return client.status()
 
 
 def list_available_commands() -> Dict[str, Any]:
-    """List available commands (convenience function)"""
+    """List available commands (convenience function)."""
     client = get_daemon_client()
     return client.list_commands()

mcli/lib/api/daemon_client_local.py

@@ -1,16 +1,14 @@
 import json
 import subprocess
-from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from mcli.lib.logger.logger import get_logger
-from mcli.lib.toml.toml import read_from_toml
 
 logger = get_logger(__name__)
 
 
 class LocalDaemonClient:
-    """Client for interacting with the MCLI Daemon via CLI subprocess (local IPC)"""
+    """Client for interacting with the MCLI Daemon via CLI subprocess (local IPC)."""
 
     def __init__(self):
         self.daemon_cmd = ["python", "-m", "mcli.workflow.daemon.daemon"]

mcli/lib/api/daemon_decorator.py

@@ -7,7 +7,7 @@ from typing import Any, Callable, Dict, List, Optional
 from mcli.lib.logger.logger import get_logger
 from mcli.lib.toml.toml import read_from_toml
 
-from .daemon_client import APIDaemonClient, get_daemon_client
+from .daemon_client import get_daemon_client
 
 logger = get_logger(__name__)
 
@@ -77,7 +77,7 @@ def daemon_command(
 
 
 def _is_daemon_routing_enabled() -> bool:
-    """Check if daemon routing is enabled in configuration"""
+    """Check if daemon routing is enabled in configuration."""
     # Check environment variable
     if os.environ.get("MCLI_DAEMON_ROUTING", "false").lower() in ("true", "1", "yes"):
         return True
@@ -102,7 +102,7 @@ def _is_daemon_routing_enabled() -> bool:
 
 
 def _convert_to_command_args(args: tuple, kwargs: dict, func: Callable) -> List[str]:
-    """Convert function arguments to command line arguments"""
+    """Convert function arguments to command line arguments."""
     cmd_args = []
 
     # Get function signature
@@ -140,7 +140,7 @@ def _convert_to_command_args(args: tuple, kwargs: dict, func: Callable) -> List[
             # *args
             if isinstance(param_value, (list, tuple)):
                 cmd_args.extend([str(arg) for arg in param_value])
-        elif param.kind == inspect.Parameter.VAR_KEYWORD:
+        elif param.kind == inspect.Parameter.VAR_KEYWORD:  # noqa: SIM102
             # **kwargs
             if isinstance(param_value, dict):
                 for key, value in param_value.items():
@@ -199,7 +199,7 @@ def daemon_group(
 
 # Convenience function to check if daemon is available
 def is_daemon_available() -> bool:
-    """Check if the API daemon is available and running"""
+    """Check if the API daemon is available and running."""
     try:
         client = get_daemon_client()
         return client.is_running()
@@ -209,7 +209,7 @@ def is_daemon_available() -> bool:
 
 # Convenience function to get daemon status
 def get_daemon_status() -> Optional[Dict[str, Any]]:
-    """Get daemon status if available"""
+    """Get daemon status if available."""
     try:
         client = get_daemon_client()
         return client.status()

mcli/lib/api/mcli_decorators.py

@@ -6,17 +6,13 @@ adding API endpoints and background processing capabilities while maintaining
 the familiar Click interface. Users only need to import mcli and get everything.
 """
 
-import functools
-import inspect
 import os
 import time
-from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Union
 
 import click
 
 from mcli.lib.logger.logger import get_logger
-from mcli.lib.toml.toml import read_from_toml
 
 from .api import api_endpoint as _api_endpoint
 from .api import get_api_app, start_api_server, stop_api_server
@@ -590,7 +586,7 @@ def get_network_credentials():
 
 # Re-export Click types and classes
 def _get_click_types():
-    """Get Click types for re-export"""
+    """Get Click types for re-export."""
     import click
 
     return {
@@ -950,14 +946,14 @@ def status_check():
 
 
 class ChatCommandGroup(click.Group):
-    """Special command group that provides chat-based interaction"""
+    """Special command group that provides chat-based interaction."""
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.chat_client = None
 
     def get_help(self, ctx):
-        """Start interactive chat session instead of showing normal help"""
+        """Start interactive chat session instead of showing normal help."""
         from mcli.chat.chat import ChatClient
 
         self.chat_client = ChatClient()
@@ -969,7 +965,7 @@ from typing import Any, Callable
 
 
 def chat(**kwargs) -> Callable[[Callable[..., Any]], click.Group]:
-    """Create a chat command group that provides an interactive LLM-powered interface"""
+    """Create a chat command group that provides an interactive LLM-powered interface."""
     kwargs.setdefault("invoke_without_command", True)
     kwargs.setdefault("no_args_is_help", False)
     return click.group(cls=ChatCommandGroup, **kwargs)

mcli/lib/auth/__init__.py

@@ -1 +0,0 @@
-from .auth import *

mcli/lib/auth/auth.py

@@ -6,7 +6,7 @@ from .token_manager import TokenManager
 
 
 def configure():
-    """Configure authentication token"""
+    """Configure authentication token."""
     token_manager = TokenManager()
 
     # Prompt for token, hiding input
@@ -25,7 +25,7 @@ def configure():
 
 
 def show_token():
-    """Display the current authentication token"""
+    """Display the current authentication token."""
     token_manager = TokenManager()
     token = token_manager.get_token()
 
@@ -36,7 +36,7 @@ def show_token():
 
 
 def clear_token():
-    """Clear the stored authentication token"""
+    """Clear the stored authentication token."""
     token_manager = TokenManager()
 
     if click.confirm("Are you sure you want to clear the stored token?"):
@@ -77,8 +77,7 @@ def get_mcli_basic_auth() -> Optional[str]:
 
 @click.group(name="auth")
 def auth():
-    """Authentication commands"""
-    pass
+    """Authentication commands."""
 
 
 if __name__ == "__main__":

mcli/lib/auth/mcli_manager.py

@@ -1,11 +1,6 @@
 import base64
-import json
-import time
-from pathlib import Path
 from urllib.request import urlopen
 
-import click
-
 from mcli.lib.logger.logger import get_logger
 
 logger = get_logger(__name__)
@@ -20,24 +15,24 @@ class MCLIManager:
         self.env_url = env_url
 
     def create_mcli_basic_auth_token(self):
-        """Create a basic auth token for MCLI authentication"""
+        """Create a basic auth token for MCLI authentication."""
         basic_content_bytes = "BA:BA".encode("ASCII")
         basic_token_b64 = base64.b64encode(basic_content_bytes).decode("ASCII")
         return basic_token_b64
 
     def create_mcli_basic_auth_header(self, token: str):
-        """Create a basic auth header for MCLI authentication"""
+        """Create a basic auth header for MCLI authentication."""
         return "Basic " + token
 
     def mcli_as_dev_user(self, url, authHeader):
-        """Connect to MCLI as a dev user"""
+        """Connect to MCLI as a dev user."""
         src = urlopen(url + "/remote/mcli.py").read()
         exec_scope = {}
         exec(src, exec_scope)
         return exec_scope["get_mcli"](url=url, authz=authHeader)
 
     def mcli_as_basic_user(self):
-        """Connect to MCLI as a BA user"""
+        """Connect to MCLI as a BA user."""
         url = self.env_url
         token = self.create_mcli_basic_auth_token()
         basicAuthHeader = self.create_mcli_basic_auth_header(token)
@@ -46,7 +41,7 @@ class MCLIManager:
 
 
 class MCLIConnectionParams:
-    """A picklable class to store MCLI connection parameters"""
+    """A picklable class to store MCLI connection parameters."""
 
     def __init__(self, url, auth_token):
         self.url = url
@@ -60,7 +55,7 @@ class MCLIInstance:
         self._mcli = self._initialize_mcli()
 
     def _normalize_url(self, url):
-        """Normalize URL to ensure it's properly formatted"""
+        """Normalize URL to ensure it's properly formatted."""
         if not url:
             raise ValueError("URL cannot be empty")
 
@@ -71,7 +66,7 @@ class MCLIInstance:
         return url.rstrip("/")
 
     def _initialize_mcli(self):
-        """Initialize the MCLI connection"""
+        """Initialize the MCLI connection."""
         mcli_url = f"{self.url}/remote/mcli.py"
 
         try:

mcli/lib/auth/token_util.py

@@ -69,7 +69,7 @@ def execute(action, args):
 
     elif action == "PROVISION_THIRDPARTY":
         ensure_directory_exists(DEV_SECRETS_ROOT + "thirdParty")
-        mcli = mcli_as_basic_user()
+        mcli = mcli_as_basic_user()  # noqa: F841
 
     else:
         help(action, args)
@@ -759,7 +759,7 @@ def get_current_version(file_path=VERSION_FILE_PATH):
         logger.info(f"Error reading file {file_path}: {e}")
         return None
 
-    if version == None:
+    if version is None:
         raise ValueError(f"File '{file_path}' does not contain version.")
     elif is_major_minor_patch(version):
         return version
@@ -866,7 +866,7 @@ def align_version(
                     for key in platform_pkgs:
                         if key in data[K_DEPS]:
                             val = data[K_DEPS][key]
-                            if val == None or val != maj_min:
+                            if val is None or val != maj_min:
                                 data[K_DEPS][key] = maj_min
                                 modified = True
 
@@ -875,7 +875,7 @@ def align_version(
                     # update version to major.minor.patch
                     if (
                         K_VERSION not in data
-                        or data[K_VERSION] == None
+                        or data[K_VERSION] is None
                         or data[K_VERSION] != version
                     ):
                         data[K_VERSION] = version
@@ -891,7 +891,7 @@ def align_version(
                     # update compatibleToVersion to previous major.minor
                     if (
                         K_COMPAT not in data
-                        or data[K_COMPAT] == None
+                        or data[K_COMPAT] is None
                         or data[K_COMPAT] != compat_version
                     ):
                         data[K_COMPAT] = compat_version

mcli/lib/config/__init__.py

@@ -1 +1,29 @@
-from .config import *
+"""Config module for MCLI."""
+
+from .config import (
+    DEV_SECRETS_ROOT,
+    ENDPOINT,
+    PACKAGES_TO_SYNC,
+    PATH_TO_PACKAGE_REPO,
+    PRIVATE_KEY_PATH,
+    USER_CONFIG_ROOT,
+    USER_INFO_FILE,
+    get_config_directory,
+    get_config_file_name,
+    get_config_for_file,
+    get_mcli_rc,
+)
+
+__all__ = [
+    "DEV_SECRETS_ROOT",
+    "ENDPOINT",
+    "PACKAGES_TO_SYNC",
+    "PATH_TO_PACKAGE_REPO",
+    "PRIVATE_KEY_PATH",
+    "USER_CONFIG_ROOT",
+    "USER_INFO_FILE",
+    "get_config_directory",
+    "get_config_file_name",
+    "get_config_for_file",
+    "get_mcli_rc",
+]

mcli/lib/config/config.py

@@ -2,7 +2,6 @@ from pathlib import Path
 
 from mcli.lib.fs import get_user_home
 from mcli.lib.logger.logger import get_logger
-from mcli.lib.toml import read_from_toml
 
 logger = get_logger(__name__)
 logger.info("")

mcli/lib/custom_commands.py

@@ -423,7 +423,7 @@ class CustomCommandManager:
                         ctx.exit(1)
                     finally:
                         # Clean up temporary file
-                        try:
+                        try:  # noqa: SIM105
                             Path(temp_file_path).unlink(missing_ok=True)
                         except Exception:
                             pass

mcli/lib/discovery/command_discovery.py

@@ -14,7 +14,7 @@ logger = get_logger(__name__)
 
 @dataclass
 class DiscoveredCommand:
-    """Represents a discovered Click command"""
+    """Represents a discovered Click command."""
 
     name: str
     full_name: str  # e.g., "workflow.file.oxps_to_pdf"
@@ -27,14 +27,14 @@ class DiscoveredCommand:
 
 
 class ClickCommandDiscovery:
-    """Discovers all Click commands in the MCLI application"""
+    """Discovers all Click commands in the MCLI application."""
 
     def __init__(self, base_path: Optional[Path] = None):
         self.base_path = base_path or Path(__file__).parent.parent.parent
         self.discovered_commands: Dict[str, DiscoveredCommand] = {}
 
     def discover_all_commands(self) -> List[DiscoveredCommand]:
-        """Discover all Click commands in the application"""
+        """Discover all Click commands in the application."""
         self.discovered_commands.clear()
 
         # Get the included directories from config
@@ -63,7 +63,7 @@ class ClickCommandDiscovery:
         return list(self.discovered_commands.values())
 
     def _discover_in_directory(self, directory: str):
-        """Discover commands in a specific directory"""
+        """Discover commands in a specific directory."""
         if "/" in directory:
             # Handle nested paths like "workflow/daemon"
             parts = directory.split("/")
@@ -90,7 +90,7 @@ class ClickCommandDiscovery:
                 logger.debug(f"Error discovering commands in {py_file}: {e}")
 
     def _discover_in_file(self, py_file: Path, base_directory: str):
-        """Discover commands in a specific Python file"""
+        """Discover commands in a specific Python file."""
         # Convert file path to module name
         relative_path = py_file.relative_to(self.base_path.parent)
         module_name = str(relative_path).replace("/", ".").replace(".py", "")
@@ -101,13 +101,13 @@ class ClickCommandDiscovery:
 
         try:
             # Import the module
-            if module_name not in sys.modules:
+            if module_name not in sys.modules:  # noqa: SIM401
                 module = importlib.import_module(module_name)
             else:
                 module = sys.modules[module_name]
 
             # Find Click objects
-            for name, obj in inspect.getmembers(module):
+            for _name, obj in inspect.getmembers(module):
                 if isinstance(obj, click.Group):
                     self._register_group(obj, module_name, base_directory)
                 elif isinstance(obj, click.Command):
@@ -117,7 +117,7 @@ class ClickCommandDiscovery:
             logger.debug(f"Could not import or inspect module {module_name}: {e}")
 
     def _register_group(self, group: click.Group, module_name: str, base_directory: str):
-        """Register a Click group and its commands"""
+        """Register a Click group and its commands."""
         group_full_name = f"{base_directory}.{group.name}" if group.name else base_directory
 
         # Register the group itself
@@ -156,7 +156,7 @@ class ClickCommandDiscovery:
                 self._register_group_recursive(cmd, cmd_full_name, module_name)
 
     def _register_command(self, command: click.Command, module_name: str, base_directory: str):
-        """Register a standalone Click command"""
+        """Register a standalone Click command."""
         cmd_full_name = f"{base_directory}.{command.name}" if command.name else base_directory
 
         cmd = DiscoveredCommand(
@@ -172,7 +172,7 @@ class ClickCommandDiscovery:
         self.discovered_commands[cmd_full_name] = cmd
 
     def _register_group_recursive(self, group: click.Group, parent_name: str, module_name: str):
-        """Recursively register nested group commands"""
+        """Recursively register nested group commands."""
         for cmd_name, cmd in group.commands.items():
             cmd_full_name = f"{parent_name}.{cmd_name}"
 
@@ -192,7 +192,7 @@ class ClickCommandDiscovery:
                 self._register_group_recursive(cmd, cmd_full_name, module_name)
 
     def get_commands(self, include_groups: bool = True) -> List[Dict[str, Any]]:
-        """Get all discovered commands as dictionaries"""
+        """Get all discovered commands as dictionaries."""
         commands = []
 
         for cmd in self.discovered_commands.values():
@@ -224,7 +224,7 @@ class ClickCommandDiscovery:
         return sorted(commands, key=lambda x: x["full_name"])
 
     def search_commands(self, query: str) -> List[Dict[str, Any]]:
-        """Search commands by name, description, or module"""
+        """Search commands by name, description, or module."""
         query = query.lower()
         all_commands = self.get_commands()
 
@@ -241,7 +241,7 @@ class ClickCommandDiscovery:
         return matching_commands
 
     def get_command_by_name(self, name: str) -> Optional[DiscoveredCommand]:
-        """Get a command by its name or full name"""
+        """Get a command by its name or full name."""
         # First try exact match by full name
         if name in self.discovered_commands:
             return self.discovered_commands[name]
@@ -259,7 +259,7 @@ _discovery_instance = None
 
 
 def get_command_discovery() -> ClickCommandDiscovery:
-    """Get a cached command discovery instance"""
+    """Get a cached command discovery instance."""
     global _discovery_instance
     if _discovery_instance is None:
         _discovery_instance = ClickCommandDiscovery()
@@ -268,7 +268,7 @@ def get_command_discovery() -> ClickCommandDiscovery:
 
 
 def refresh_command_discovery():
-    """Refresh the command discovery cache"""
+    """Refresh the command discovery cache."""
     global _discovery_instance
     _discovery_instance = None
     return get_command_discovery()