mcli-framework 7.0.0__py3-none-any.whl

mcli/lib/api/daemon_client.py

@@ -0,0 +1,203 @@
+import json
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from mcli.lib.logger.logger import get_logger
+from mcli.lib.toml.toml import read_from_toml
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class DaemonClientConfig:
+    """Configuration for daemon client"""
+
+    host: str = "localhost"
+    port: int = 8000
+    timeout: int = 30
+    retry_attempts: int = 3
+    retry_delay: float = 1.0
+
+
+class APIDaemonClient:
+    """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()
+        self.shell_mode = shell_mode
+        # If shell_mode, always use Flask test server at 0.0.0.0:5005
+        if shell_mode:
+            self.base_url = "http://localhost:5005"
+        else:
+            self.base_url = f"http://{self.config.host}:{self.config.port}"
+        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"
+        try:
+            response = self.session.post(
+                url, json={"command": command}, timeout=self.config.timeout
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Failed to connect to Flask shell daemon at {url}: {e}")
+
+    def _load_config(self) -> DaemonClientConfig:
+        """Load configuration from config files"""
+        config = DaemonClientConfig()
+
+        # Try to load from config.toml files
+        config_paths = [
+            Path("config.toml"),  # Current directory
+            Path.home() / ".config" / "mcli" / "config.toml",  # User config
+            Path(__file__).parent.parent.parent.parent.parent / "config.toml",  # Project root
+        ]
+
+        for path in config_paths:
+            if path.exists():
+                try:
+                    daemon_config = read_from_toml(str(path), "api_daemon")
+                    if daemon_config:
+                        if daemon_config.get("host"):
+                            config.host = daemon_config["host"]
+                        if daemon_config.get("port"):
+                            config.port = daemon_config["port"]
+                        logger.debug(f"Loaded daemon client config from {path}")
+                        break
+                except Exception as e:
+                    logger.debug(f"Could not load daemon client config from {path}: {e}")
+
+        return config
+
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict] = None,
+        params: Optional[Dict] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Make HTTP request to daemon with retry logic"""
+        url = f"{self.base_url}{endpoint}"
+        for attempt in range(self.config.retry_attempts):
+            try:
+                if method.upper() == "GET":
+                    response = self.session.request(
+                        method=method, url=url, params=params, timeout=self.config.timeout, **kwargs
+                    )
+                else:
+                    response = self.session.request(
+                        method=method, url=url, json=data, timeout=self.config.timeout, **kwargs
+                    )
+                response.raise_for_status()
+                return response.json()
+            except requests.exceptions.RequestException as e:
+                if attempt == self.config.retry_attempts - 1:
+                    raise Exception(f"Failed to connect to API daemon at {url}: {e}")
+                logger.warning(
+                    f"Attempt {attempt + 1} failed, retrying in {self.config.retry_delay}s..."
+                )
+                time.sleep(self.config.retry_delay)
+        return {}  # Always return a dict
+
+    def health_check(self) -> Dict[str, Any]:
+        """Check daemon health"""
+        return self._make_request("GET", "/health")
+
+    def status(self) -> Dict[str, Any]:
+        """Get daemon status"""
+        return self._make_request("GET", "/status")
+
+    def list_commands(self, all: bool = False) -> Dict[str, Any]:
+        """List available commands with metadata. If all=True, include inactive."""
+        params = {"all": str(all).lower()} if all else None
+        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"""
+        return self._make_request("GET", f"/commands/{command_id}")
+
+    def execute_command(
+        self,
+        command_id: Optional[str] = None,
+        command_name: Optional[str] = None,
+        args: Optional[List[str]] = None,
+        timeout: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """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")
+
+        data = {
+            "args": args or [],
+        }
+        if command_id is not None:
+            data["command_id"] = command_id
+        if command_name is not None:
+            data["command_name"] = command_name
+        if timeout is not None:
+            data["timeout"] = timeout
+        return self._make_request("POST", "/execute", data=data)
+
+    def start_daemon(self) -> Dict[str, Any]:
+        """Start the daemon via HTTP"""
+        return self._make_request("POST", "/daemon/start")
+
+    def stop_daemon(self) -> Dict[str, Any]:
+        """Stop the daemon via HTTP"""
+        return self._make_request("POST", "/daemon/stop")
+
+    def is_running(self) -> bool:
+        """Check if daemon is running"""
+        try:
+            status = self.status()
+            return status.get("running", False)
+        except Exception:
+            return False
+
+    def wait_for_daemon(self, timeout: int = 30) -> bool:
+        """Wait for daemon to be ready"""
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if self.is_running():
+                return True
+            time.sleep(1)
+        return False
+
+
+# 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)"""
+    client = APIDaemonClient(shell_mode=True)
+    return client.execute_shell_command(command)
+
+
+def get_daemon_client() -> APIDaemonClient:
+    """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)"""
+    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)"""
+    client = get_daemon_client()
+    return client.status()
+
+
+def list_available_commands() -> Dict[str, Any]:
+    """List available commands (convenience function)"""
+    client = get_daemon_client()
+    return client.list_commands()

mcli/lib/api/daemon_client_local.py

@@ -0,0 +1,44 @@
+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)"""
+
+    def __init__(self):
+        self.daemon_cmd = ["python", "-m", "mcli.workflow.daemon.daemon"]
+        # Optionally, you could use the installed CLI: ["mcli-daemon"]
+
+    def list_commands(self) -> Dict[str, Any]:
+        logger.info("[LocalDaemonClient] Invoking 'list-commands' via subprocess")
+        result = subprocess.run(
+            self.daemon_cmd + ["list-commands", "--json"], capture_output=True, text=True
+        )
+        logger.info(f"[LocalDaemonClient] stdout: {result.stdout}\nstderr: {result.stderr}")
+        if result.returncode != 0:
+            raise Exception(f"Daemon list-commands failed: {result.stderr}")
+        return json.loads(result.stdout)
+
+    def execute_command(
+        self, command_name: str, args: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        logger.info(f"[LocalDaemonClient] Invoking 'execute' for {command_name} via subprocess")
+        cmd = self.daemon_cmd + ["execute", command_name] + (args or []) + ["--json"]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        logger.info(f"[LocalDaemonClient] stdout: {result.stdout}\nstderr: {result.stderr}")
+        if result.returncode != 0:
+            raise Exception(f"Daemon execute failed: {result.stderr}")
+        return json.loads(result.stdout)
+
+    # Add more methods as needed for other daemon features
+
+
+def get_local_daemon_client():
+    return LocalDaemonClient()

mcli/lib/api/daemon_decorator.py

@@ -0,0 +1,217 @@
+import functools
+import inspect
+import os
+from pathlib import Path
+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
+
+logger = get_logger(__name__)
+
+
+def daemon_command(
+    command_name: Optional[str] = None,
+    auto_route: bool = True,
+    fallback_to_local: bool = True,
+    timeout: Optional[int] = None,
+):
+    """
+    Decorator to route Click commands to the API daemon when enabled.
+
+    Args:
+        command_name: Name of the command (defaults to function name)
+        auto_route: Whether to automatically route to daemon if enabled
+        fallback_to_local: Whether to fallback to local execution if daemon fails
+        timeout: Command timeout in seconds
+    """
+
+    def decorator(func: Callable) -> Callable:
+        # Get command name
+        cmd_name = command_name or func.__name__
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # Check if daemon routing is enabled
+            if not auto_route or not _is_daemon_routing_enabled():
+                return func(*args, **kwargs)
+
+            try:
+                # Try to execute via daemon
+                client = get_daemon_client()
+
+                # Convert args and kwargs to command arguments
+                cmd_args = _convert_to_command_args(args, kwargs, func)
+
+                # Execute via daemon
+                result = client.execute_command(
+                    command_name=cmd_name, args=cmd_args, timeout=timeout
+                )
+
+                if result.get("success"):
+                    logger.info(f"Command '{cmd_name}' executed successfully via daemon")
+                    return result.get("result")
+                else:
+                    logger.warning(
+                        f"Daemon execution failed for '{cmd_name}': {result.get('error')}"
+                    )
+                    if fallback_to_local:
+                        logger.info(f"Falling back to local execution for '{cmd_name}'")
+                        return func(*args, **kwargs)
+                    else:
+                        raise Exception(f"Daemon execution failed: {result.get('error')}")
+
+            except Exception as e:
+                logger.warning(f"Failed to execute '{cmd_name}' via daemon: {e}")
+                if fallback_to_local:
+                    logger.info(f"Falling back to local execution for '{cmd_name}'")
+                    return func(*args, **kwargs)
+                else:
+                    raise
+
+        return wrapper
+
+    return decorator
+
+
+def _is_daemon_routing_enabled() -> bool:
+    """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
+
+    # Check config files
+    config_paths = [
+        Path("config.toml"),  # Current directory
+        Path.home() / ".config" / "mcli" / "config.toml",  # User config
+        Path(__file__).parent.parent.parent.parent.parent / "config.toml",  # Project root
+    ]
+
+    for path in config_paths:
+        if path.exists():
+            try:
+                daemon_config = read_from_toml(str(path), "api_daemon")
+                if daemon_config and daemon_config.get("enabled", False):
+                    return True
+            except Exception as e:
+                logger.debug(f"Could not read daemon config from {path}: {e}")
+
+    return False
+
+
+def _convert_to_command_args(args: tuple, kwargs: dict, func: Callable) -> List[str]:
+    """Convert function arguments to command line arguments"""
+    cmd_args = []
+
+    # Get function signature
+    sig = inspect.signature(func)
+    bound_args = sig.bind(*args, **kwargs)
+    bound_args.apply_defaults()
+
+    # Convert to command line arguments
+    for param_name, param_value in bound_args.arguments.items():
+        param = sig.parameters[param_name]
+
+        # Skip self parameter for methods
+        if param_name == "self":
+            continue
+
+        # Handle different parameter types
+        if param.kind == inspect.Parameter.POSITIONAL_ONLY:
+            # Positional argument
+            if param_value is not None:
+                cmd_args.append(str(param_value))
+        elif param.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD:
+            # Can be positional or keyword
+            if param_value is not None:
+                if param.default == inspect.Parameter.empty:
+                    # Required argument
+                    cmd_args.append(str(param_value))
+                else:
+                    # Optional argument with value
+                    cmd_args.extend([f"--{param_name}", str(param_value)])
+        elif param.kind == inspect.Parameter.KEYWORD_ONLY:
+            # Keyword-only argument
+            if param_value is not None and param_value != param.default:
+                cmd_args.extend([f"--{param_name}", str(param_value)])
+        elif param.kind == inspect.Parameter.VAR_POSITIONAL:
+            # *args
+            if isinstance(param_value, (list, tuple)):
+                cmd_args.extend([str(arg) for arg in param_value])
+        elif param.kind == inspect.Parameter.VAR_KEYWORD:
+            # **kwargs
+            if isinstance(param_value, dict):
+                for key, value in param_value.items():
+                    cmd_args.extend([f"--{key}", str(value)])
+
+    return cmd_args
+
+
+def daemon_group(
+    group_name: Optional[str] = None, auto_route: bool = True, fallback_to_local: bool = True
+):
+    """
+    Decorator to route Click groups to the API daemon when enabled.
+
+    Args:
+        group_name: Name of the group (defaults to function name)
+        auto_route: Whether to automatically route to daemon if enabled
+        fallback_to_local: Whether to fallback to local execution if daemon fails
+    """
+
+    def decorator(func: Callable) -> Callable:
+        # Get group name
+        grp_name = group_name or func.__name__
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # Check if daemon routing is enabled
+            if not auto_route or not _is_daemon_routing_enabled():
+                return func(*args, **kwargs)
+
+            try:
+                # Try to execute via daemon
+                client = get_daemon_client()
+
+                # For groups, we'll just check if the daemon is available
+                # and then fall back to local execution
+                if client.is_running():
+                    logger.info(
+                        f"Daemon is running, but group '{grp_name}' will be executed locally"
+                    )
+
+                return func(*args, **kwargs)
+
+            except Exception as e:
+                logger.warning(f"Failed to check daemon for group '{grp_name}': {e}")
+                if fallback_to_local:
+                    logger.info(f"Falling back to local execution for group '{grp_name}'")
+                    return func(*args, **kwargs)
+                else:
+                    raise
+
+        return wrapper
+
+    return decorator
+
+
+# Convenience function to check if daemon is available
+def is_daemon_available() -> bool:
+    """Check if the API daemon is available and running"""
+    try:
+        client = get_daemon_client()
+        return client.is_running()
+    except Exception:
+        return False
+
+
+# Convenience function to get daemon status
+def get_daemon_status() -> Optional[Dict[str, Any]]:
+    """Get daemon status if available"""
+    try:
+        client = get_daemon_client()
+        return client.status()
+    except Exception:
+        return None