comfygit-core 0.2.0__py3-none-any.whl

comfygit_core/utils/retry.py

@@ -0,0 +1,242 @@
+"""Retry utilities with exponential backoff for API rate limiting."""
+
+import random
+import time
+import urllib.error
+from collections.abc import Callable
+from functools import wraps
+from typing import Any
+
+from ..logging.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class RetryConfig:
+    """Configuration for retry behavior."""
+
+    def __init__(
+        self,
+        max_retries: int = 5,
+        initial_delay: float = 1.0,
+        max_delay: float = 60.0,
+        exponential_base: float = 2.0,
+        jitter: bool = True,
+    ):
+        """Initialize retry configuration.
+
+        Args:
+            max_retries: Maximum number of retry attempts
+            initial_delay: Initial delay in seconds
+            max_delay: Maximum delay in seconds
+            exponential_base: Base for exponential backoff
+            jitter: Add random jitter to delays
+        """
+        self.max_retries = max_retries
+        self.initial_delay = initial_delay
+        self.max_delay = max_delay
+        self.exponential_base = exponential_base
+        self.jitter = jitter
+
+
+def calculate_backoff_delay(attempt: int, config: RetryConfig) -> float:
+    """Calculate exponential backoff delay with optional jitter.
+
+    Args:
+        attempt: Current attempt number (0-based)
+        config: Retry configuration
+
+    Returns:
+        Delay in seconds
+    """
+    # Calculate exponential backoff
+    delay = min(
+        config.initial_delay * (config.exponential_base**attempt), config.max_delay
+    )
+
+    # Add jitter if enabled
+    if config.jitter:
+        # Add random jitter between 0 and 25% of the delay
+        jitter_amount = delay * 0.25 * random.random()
+        delay += jitter_amount
+
+    return delay
+
+
+def is_rate_limit_error(error: Exception) -> bool:
+    """Check if an error is a rate limit error.
+
+    Args:
+        error: The exception to check
+
+    Returns:
+        True if this is a rate limit error
+    """
+    if isinstance(error, urllib.error.HTTPError):
+        # GitHub returns 403 for rate limits
+        if error.code == 403:
+            # Check headers for rate limit indication
+            headers = error.headers
+            if headers.get("X-RateLimit-Remaining") == "0":
+                return True
+            # Also check for rate limit message in response
+            try:
+                error_data = error.read().decode("utf-8")
+                if (
+                    "rate limit" in error_data.lower()
+                    or "api rate limit" in error_data.lower()
+                ):
+                    return True
+            except Exception:
+                pass
+        # Some APIs return 429 for rate limits
+        elif error.code == 429:
+            return True
+
+    return False
+
+
+def retry_on_rate_limit(config: RetryConfig | None = None):
+    """Decorator for retrying functions that may hit rate limits.
+
+    Args:
+        config: Retry configuration (uses defaults if not provided)
+
+    Returns:
+        Decorated function
+    """
+    if config is None:
+        config = RetryConfig()
+
+    def decorator(func: Callable):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            last_exception = None
+
+            for attempt in range(config.max_retries + 1):
+                try:
+                    return func(*args, **kwargs)
+
+                except Exception as e:
+                    last_exception = e
+
+                    # Check if this is a rate limit error
+                    if is_rate_limit_error(e):
+                        if attempt < config.max_retries:
+                            delay = calculate_backoff_delay(attempt, config)
+                            logger.warning(
+                                f"Rate limit hit in {func.__name__}, "
+                                f"retrying in {delay:.1f}s (attempt {attempt + 1}/{config.max_retries})"
+                            )
+                            time.sleep(delay)
+                            continue
+                        else:
+                            logger.error(
+                                f"Rate limit hit in {func.__name__}, "
+                                f"max retries ({config.max_retries}) exceeded"
+                            )
+
+                    # Re-raise if not a rate limit error
+                    raise
+
+            # If we get here, we've exhausted retries
+            if last_exception:
+                raise last_exception
+
+        return wrapper
+
+    return decorator
+
+
+def retry_with_backoff(
+    func: Callable,
+    args: tuple = (),
+    kwargs: dict | None = None,
+    config: RetryConfig | None = None,
+    on_retry: Callable[[int, Exception], None] | None = None,
+) -> Any:
+    """Execute a function with retry logic and exponential backoff.
+
+    Args:
+        func: Function to execute
+        args: Positional arguments for the function
+        kwargs: Keyword arguments for the function
+        config: Retry configuration
+        on_retry: Optional callback called on each retry with (attempt, exception)
+
+    Returns:
+        Result of the function call
+
+    Raises:
+        The last exception if all retries are exhausted
+    """
+    if kwargs is None:
+        kwargs = {}
+    if config is None:
+        config = RetryConfig()
+
+    last_exception = None
+
+    for attempt in range(config.max_retries + 1):
+        try:
+            return func(*args, **kwargs)
+
+        except Exception as e:
+            last_exception = e
+
+            # Check if this is a rate limit error
+            if is_rate_limit_error(e):
+                if attempt < config.max_retries:
+                    delay = calculate_backoff_delay(attempt, config)
+
+                    # Call retry callback if provided
+                    if on_retry:
+                        on_retry(attempt, e)
+
+                    logger.warning(
+                        f"Rate limit hit, retrying in {delay:.1f}s "
+                        f"(attempt {attempt + 1}/{config.max_retries})"
+                    )
+                    time.sleep(delay)
+                    continue
+                else:
+                    logger.error(
+                        f"Rate limit hit, max retries ({config.max_retries}) exceeded"
+                    )
+
+            # Re-raise if not a rate limit error or if retries exhausted
+            raise
+
+    # Should not reach here, but just in case
+    if last_exception:
+        raise last_exception
+
+
+class RateLimitManager:
+    """Manages rate limiting across multiple API calls."""
+
+    def __init__(self, min_interval: float = 0.1):
+        """Initialize rate limit manager.
+
+        Args:
+            min_interval: Minimum interval between API calls in seconds
+        """
+        self.min_interval = min_interval
+        self.last_call_time = {}
+
+    def wait_if_needed(self, api_key: str):
+        """Wait if necessary to respect rate limits.
+
+        Args:
+            api_key: Unique key for the API being called
+        """
+        current_time = time.time()
+
+        if api_key in self.last_call_time:
+            elapsed = current_time - self.last_call_time[api_key]
+            if elapsed < self.min_interval:
+                sleep_time = self.min_interval - elapsed
+                logger.debug(f"Rate limiting: sleeping for {sleep_time:.3f}s")
+                time.sleep(sleep_time)
+
+        self.last_call_time[api_key] = time.time()

comfygit_core/utils/symlink_utils.py

@@ -0,0 +1,119 @@
+"""Shared utilities for cross-platform symlink operations."""
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+from ..models.exceptions import CDEnvironmentError
+
+
+def is_link(path: Path) -> bool:
+    """Detect both symlinks and junctions (Windows).
+
+    Args:
+        path: Path to check
+
+    Returns:
+        True if path is a symlink or junction, False otherwise
+    """
+    if path.is_symlink():
+        return True
+    # Python 3.12+: Direct junction check
+    if hasattr(os.path, 'isjunction') and os.path.isjunction(path):
+        return True
+    # Fallback: Check if path resolution differs (works for junctions and symlinks)
+    try:
+        return path.exists() and path.absolute() != path.resolve()
+    except (OSError, RuntimeError):
+        return False
+
+
+def create_platform_link(link_path: Path, target_path: Path, name: str) -> None:
+    """Create symlink (Unix) or junction (Windows).
+
+    Args:
+        link_path: Path where symlink should be created
+        target_path: Path that symlink should point to
+        name: Directory name for error messages (e.g., "models", "input")
+
+    Raises:
+        CDEnvironmentError: If link creation fails
+    """
+    try:
+        if os.name == "nt":  # Windows
+            create_windows_junction(link_path, target_path, name)
+        else:  # Linux/macOS
+            os.symlink(target_path, link_path)
+    except CDEnvironmentError:
+        # Re-raise CDEnvironmentError as-is
+        raise
+    except Exception as e:
+        raise CDEnvironmentError(f"Failed to create {name} symlink: {e}") from e
+
+
+def create_windows_junction(link_path: Path, target_path: Path, name: str) -> None:
+    """Create junction on Windows using mklink command.
+
+    Args:
+        link_path: Path where junction should be created
+        target_path: Path that junction should point to
+        name: Directory name for error messages
+
+    Raises:
+        CDEnvironmentError: If junction creation fails
+    """
+    # Use mklink /J for directory junction (no admin required)
+    result = subprocess.run(
+        [
+            "mklink",
+            "/J",
+            str(link_path),
+            str(target_path),
+        ],
+        shell=True,  # Required for mklink
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        raise CDEnvironmentError(
+            f"Failed to create {name} junction:\n"
+            f"  Command: mklink /J {link_path} {target_path}\n"
+            f"  Error: {result.stderr}\n"
+            f"  Note: On Windows, you may need Administrator privileges or Developer Mode enabled"
+        )
+
+
+def is_safe_to_delete(path: Path, safe_files: set[str]) -> bool:
+    """Check if directory is safe to delete.
+
+    Safe to delete if:
+    - Completely empty
+    - Only contains empty subdirectories
+    - Only contains placeholder files from safe_files set
+
+    Args:
+        path: Directory path to check
+        safe_files: Set of filenames that are safe to delete (e.g., {".gitkeep", ".gitignore"})
+
+    Returns:
+        True if safe to delete, False if contains actual content
+    """
+    if not path.exists():
+        return True  # Nonexistent is safe
+
+    # Get all files recursively
+    all_items = list(path.rglob("*"))
+    files = [f for f in all_items if f.is_file()]
+
+    if len(files) == 0:
+        return True  # Completely empty (or only empty dirs)
+
+    # Check if files are only placeholders
+    for file in files:
+        if file.name not in safe_files:
+            # Has actual content
+            return False
+
+    return True  # Only placeholder files

comfygit_core/utils/system_detector.py

@@ -0,0 +1,258 @@
+"""System detector for Python, CUDA, and PyTorch detection."""
+import json
+import platform
+import re
+import sys
+from pathlib import Path
+
+from ..logging.logging_config import get_logger
+from ..models.shared import SystemInfo
+from .common import run_command
+
+
+class SystemDetector:
+    """Detects system-level dependencies like Python, CUDA, and PyTorch."""
+
+    def __init__(self, comfyui_path: Path, python_hint: Path | None = None):
+        self.logger = get_logger(__name__)
+        self.comfyui_path = Path(comfyui_path).resolve()
+        # Don't resolve the Python hint - keep the original path the user provided
+        # This preserves venv paths instead of following symlinks
+        self.python_hint = Path(python_hint) if python_hint else None
+
+        # Log the python hint for debugging
+        if self.python_hint:
+            self.logger.info(f"System detector initialized with python hint: {self.python_hint}")
+            # Remove debug print statement
+        else:
+            self.logger.info("System detector initialized without python hint")
+
+
+    def detect_all(self) -> SystemInfo:
+        """Detect all system information and return typed result.
+        
+        Returns:
+            SystemInfo: Structured system information
+        """
+        self.logger.info("Starting system detection...")
+
+        # Find Python executable
+        python_exe = self._find_python_executable()
+
+        # Detect Python version
+        python_info = self._detect_python_version(python_exe)
+
+        # Detect CUDA version
+        cuda_version = self._detect_cuda_version()
+
+        # Detect PyTorch version
+        pytorch_info = self._detect_pytorch_version(python_exe)
+
+        # Create SystemInfo object
+        system_info = SystemInfo(
+            python_executable=python_exe,
+            python_version=python_info['python_version'],
+            python_major_minor=python_info.get('python_major_minor'),
+            cuda_version=cuda_version,
+            torch_version=pytorch_info.get('torch') if pytorch_info else None,
+            cuda_torch_version=pytorch_info.get('cuda_torch_version') if pytorch_info else None,
+            pytorch_info=pytorch_info,
+            platform=platform.platform(),
+            architecture=platform.machine()
+        )
+
+        return system_info
+
+    def _find_python_executable(self) -> Path:
+        """
+        Find the Python executable and virtual environment used by ComfyUI.
+        
+        Args:
+            comfyui_path: Path to ComfyUI directory
+            python_hint: Direct path to Python executable (if provided by user)
+        
+        Returns:
+            Path to python_executable
+        """
+        # 1. If user provided python path, validate and use it
+        if self.python_hint and self.python_hint.exists():
+            self.logger.info(f"Validating user-provided Python executable: {self.python_hint}")
+            # For user-provided path, be more lenient - just check it's a valid Python
+            try:
+                result = run_command(
+                    [str(self.python_hint), "-c", "import sys; print(sys.executable)"],
+                    timeout=5
+                )
+                if result.returncode == 0:
+                    self.logger.info(f"User-provided Python executable is valid: {self.python_hint}")
+                    return self.python_hint
+                else:
+                    self.logger.warning(f"User-provided Python executable failed validation: {self.python_hint}")
+            except Exception as e:
+                self.logger.warning(f"Error validating user-provided Python: {e}")
+
+        # 2. Check for virtual environments in standard locations relative to ComfyUI
+        # Check common venv locations
+        venv_candidates = [
+            self.comfyui_path / "venv",
+            self.comfyui_path / ".venv",
+            self.comfyui_path / "env",
+            self.comfyui_path.parent / "venv",
+            self.comfyui_path.parent / ".venv",
+        ]
+
+        for venv_path in venv_candidates:
+            # Check for Python in different locations based on OS
+            if platform.system() == "Windows":
+                python_paths = [
+                    venv_path / "Scripts" / "python.exe",
+                    venv_path / "python.exe",
+                ]
+            else:
+                python_paths = [
+                    venv_path / "bin" / "python",
+                    venv_path / "bin" / "python3",
+                ]
+
+            for python_path in python_paths:
+                if python_path.exists():
+                    self.logger.info(f"Found Python executable: {python_path}")
+                    self.logger.info(f"Found virtual environment: {venv_path}")
+                    return python_path
+
+        # Check if there's a .venv file pointing to a venv
+        venv_file = self.comfyui_path / ".venv"
+        if venv_file.exists() and venv_file.is_file():
+            try:
+                venv_path = Path(venv_file.read_text(encoding='utf-8').strip())
+                if venv_path.exists():
+                    if platform.system() == "Windows":
+                        python_executable = venv_path / "Scripts" / "python.exe"
+                    else:
+                        python_executable = venv_path / "bin" / "python"
+                    if python_executable.exists():
+                        self.logger.info(f"Found Python executable via .venv file: {python_executable}")
+                        self.logger.info(f"Found virtual environment: {venv_path}")
+                        return python_executable
+            except Exception:
+                pass
+
+        # If no venv found, check if ComfyUI can run with system Python
+        self.logger.warning("No virtual environment found, checking system Python...")
+
+        # Try to run ComfyUI's main.py with --help to see if it works
+        try:
+            result = run_command(
+                [sys.executable, str(self.comfyui_path / "main.py"), "--help"],
+                timeout=5
+            )
+            if result.returncode == 0:
+                python_executable = Path(sys.executable)
+                self.logger.info(f"ComfyUI appears to work with system Python: {sys.executable}")
+                return python_executable
+        except Exception:
+            pass
+
+        self.logger.warning("Could not determine Python executable for ComfyUI")
+        return Path(sys.executable)
+
+    def _run_python_command(self, code: str, python_executable: Path) -> str | None:
+        """Run Python code in the ComfyUI environment and return output."""
+        try:
+            result = run_command(
+                [str(python_executable), "-c", code],
+                cwd=self.comfyui_path,
+                timeout=10
+            )
+            if result.returncode == 0:
+                return result.stdout.strip()
+            else:
+                self.logger.error(f"Error running Python command: {result.stderr}")
+                return None
+        except Exception as e:
+            self.logger.error(f"Exception running Python command: {e}")
+            return None
+
+
+    def _detect_python_version(self, python_executable: Path) -> dict[str, str]:
+        """Detect the Python version being used by ComfyUI."""
+        code = "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}')"
+        python_version = self._run_python_command(code, python_executable)
+
+        assert python_version is not None
+
+        major_minor = '.'.join(python_version.split('.')[:2])
+        self.logger.info(f"Python version: {python_version}")
+
+        return {
+            'python_version': python_version,
+            'python_major_minor': major_minor
+        }
+
+    def _detect_cuda_version(self) -> str | None:
+        """Detect CUDA version using nvidia-smi."""
+        try:
+            result = run_command(['nvidia-smi'])
+            if result.returncode == 0:
+                # Parse CUDA version from nvidia-smi output
+                match = re.search(r'CUDA Version:\s*(\d+\.\d+)', result.stdout)
+                if match:
+                    cuda_version = match.group(1)
+                    self.logger.info(f"CUDA version: {cuda_version}")
+                    return cuda_version
+        except Exception as e:
+            self.logger.debug(f"Could not detect CUDA: {e}")
+
+        self.logger.info("No CUDA detected (CPU-only mode)")
+        return None
+
+    def _detect_pytorch_version(self, python_executable: Path) -> dict[str, str] | None:
+        """Detect PyTorch and related library versions in ComfyUI environment."""
+        # Log which Python we're checking for PyTorch
+        self.logger.info(f"Checking for PyTorch using Python: {python_executable}")
+
+        # Check if PyTorch is installed in the ComfyUI environment
+        code = """
+import json
+try:
+    import torch
+    info = {
+        'torch': torch.__version__,
+        'cuda_available': torch.cuda.is_available(),
+        'cuda_torch_version': torch.version.cuda if torch.cuda.is_available() else None
+    }
+    
+    # Try to detect torchvision and torchaudio
+    try:
+        import torchvision
+        info['torchvision'] = torchvision.__version__
+    except ImportError:
+        pass
+        
+    try:
+        import torchaudio
+        info['torchaudio'] = torchaudio.__version__
+    except ImportError:
+        pass
+        
+    print(json.dumps(info))
+except ImportError:
+    print(json.dumps({'error': 'PyTorch not installed'}))
+"""
+
+        output = self._run_python_command(code, python_executable)
+        if output:
+            try:
+                pytorch_info = json.loads(output)
+                if 'error' not in pytorch_info:
+                    self.logger.info(f"PyTorch version: {pytorch_info.get('torch')}")
+                    if pytorch_info.get('cuda_torch_version'):
+                        self.logger.info(f"PyTorch CUDA: {pytorch_info.get('cuda_torch_version')}")
+                else:
+                    self.logger.warning("PyTorch not found in ComfyUI environment")
+                    return None
+                return pytorch_info
+            except json.JSONDecodeError:
+                self.logger.warning("Could not parse PyTorch information")
+
+        return None

comfygit_core/utils/uuid.py

@@ -0,0 +1,28 @@
+"""UUID detection utilities for subgraph support."""
+import re
+
+# RFC 4122 UUID format: 8-4-4-4-12 hex digits
+UUID_PATTERN = re.compile(
+    r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$',
+    re.IGNORECASE
+)
+
+
+def is_uuid(value: str) -> bool:
+    """Check if string is a valid UUID (subgraph reference).
+
+    Args:
+        value: String to check
+
+    Returns:
+        True if value matches UUID format
+
+    Examples:
+        >>> is_uuid("0a58ac1f-cb15-4e01-aab3-26292addb965")
+        True
+        >>> is_uuid("CheckpointLoaderSimple")
+        False
+        >>> is_uuid("not-a-valid-uuid")
+        False
+    """
+    return bool(UUID_PATTERN.match(value))