comfygit-core 0.2.0__py3-none-any.whl

comfygit_core/utils/uv_error_handler.py

@@ -0,0 +1,158 @@
+"""Utilities for handling and formatting UV command errors."""
+
+import logging
+import re
+from typing import Optional
+
+from ..models.exceptions import UVCommandError
+
+
+def parse_failed_dependency_group(stderr: str) -> Optional[str]:
+    """Parse UV error to extract the dependency group that caused build failure.
+
+    UV includes helpful context in build errors:
+    "help: `package` (vX.Y.Z) was included because
+           `project-name:group-name` (vX.Y.Z) depends on `package>=X.Y.Z`"
+
+    Args:
+        stderr: UV command stderr output
+
+    Returns:
+        Group name if found (e.g., "optional-sageattn"), None otherwise
+    """
+    if not stderr:
+        return None
+
+    # Pattern matches: `project-name:group-name` in the "was included because" line
+    pattern = r"was included because\s+`[^:]+:([^`]+)`"
+    match = re.search(pattern, stderr)
+
+    if match:
+        return match.group(1)
+
+    return None
+
+
+def extract_uv_error_hint(stderr: str) -> Optional[str]:
+    """Extract the most useful error hint from UV stderr output.
+
+    UV typically formats errors with:
+    - Lines starting with "error:"
+    - Lines containing "conflict"
+    - Multi-line dependency resolution explanations
+    - The final/last non-empty line often contains the key message
+
+    Args:
+        stderr: The stderr output from UV command
+
+    Returns:
+        Most relevant error line, or None if stderr is empty
+    """
+    if not stderr or not stderr.strip():
+        return None
+
+    lines = [line.strip() for line in stderr.strip().split('\n') if line.strip()]
+
+    if not lines:
+        return None
+
+    # Search for lines with error keywords (in reverse - most recent first)
+    error_keywords = ['error:', 'conflict', 'unsatisfiable', 'incompatible', 'failed', '× ']
+
+    for line in reversed(lines):
+        lower_line = line.lower()
+        if any(keyword in lower_line for keyword in error_keywords):
+            return line
+
+    # No keyword found - return last non-empty line
+    return lines[-1]
+
+
+def log_uv_error(logger: logging.Logger, error: UVCommandError, context: str) -> None:
+    """Log complete UV error details for debugging.
+
+    Logs all available error information:
+    - Context (node name, operation, etc.)
+    - Command that was executed
+    - Return code
+    - Full stderr output
+    - Full stdout output (if present)
+
+    Args:
+        logger: Logger instance to use
+        error: The UVCommandError exception
+        context: Context string (e.g., node name, operation)
+    """
+    logger.error(f"UV command failed for '{context}'")
+
+    if error.command:
+        logger.error(f"  Command: {' '.join(error.command)}")
+
+    if error.returncode is not None:
+        logger.error(f"  Return code: {error.returncode}")
+
+    if error.stderr:
+        logger.error(f"  STDERR:\n{error.stderr}")
+
+    if error.stdout:
+        logger.error(f"  STDOUT:\n{error.stdout}")
+
+
+def format_uv_error_for_user(error: UVCommandError, max_hint_length: int = 300) -> str:
+    """Format UV error for user-facing display.
+
+    Provides a concise, helpful error message with:
+    - Clear error type
+    - Truncated error hint from stderr
+    - Reference to logs for full details
+
+    Args:
+        error: The UVCommandError exception
+        max_hint_length: Maximum length for error hint display
+
+    Returns:
+        User-friendly error message
+    """
+    base_msg = "UV dependency resolution failed"
+
+    # Try to extract helpful hint
+    if error.stderr:
+        hint = extract_uv_error_hint(error.stderr)
+        if hint:
+            # Truncate if too long
+            if len(hint) > max_hint_length:
+                hint = hint[:max_hint_length] + "..."
+            return f"{base_msg} - {hint}"
+
+    return base_msg
+
+
+def handle_uv_error(
+    error: UVCommandError,
+    context: str,
+    logger: logging.Logger,
+    max_hint_length: int = 300
+) -> tuple[str, bool]:
+    """Complete UV error handling: log details + return user message.
+
+    This is the main entry point for handling UV errors in the CLI.
+    It performs both logging and user message formatting in one call.
+
+    Args:
+        error: The UVCommandError exception
+        context: Context string (e.g., node name, operation)
+        logger: Logger instance to use for detailed logging
+        max_hint_length: Maximum length for error hint in user message
+
+    Returns:
+        Tuple of (user_message, logs_written)
+        - user_message: Brief message to show to user
+        - logs_written: True if detailed logs were written
+    """
+    # Log complete error details
+    log_uv_error(logger, error, context)
+
+    # Format user-friendly message
+    user_msg = format_uv_error_for_user(error, max_hint_length)
+
+    return user_msg, True

comfygit_core/utils/version.py

@@ -0,0 +1,73 @@
+"""Version comparison and PyTorch utilities."""
+
+import re
+
+from ..constants import PYTORCH_PACKAGE_NAMES
+
+
+def is_pytorch_package(package_name: str, pytorch_packages: set[str] = PYTORCH_PACKAGE_NAMES) -> bool:
+    """Check if a package is PyTorch-related."""
+    package_lower = package_name.lower()
+
+    # Check against known PyTorch packages (includes triton now)
+    if package_lower in pytorch_packages:
+        return True
+
+    # Check for NVIDIA CUDA packages with cu11/cu12 suffix using regex
+    # This matches current and future nvidia packages that end with -cu11 or -cu12
+    if package_lower.startswith('nvidia-'):
+        # Use regex to match nvidia-*-cu11 or nvidia-*-cu12 pattern
+        if re.match(r'^nvidia-.*-cu(11|12)$', package_lower):
+            return True
+        # If it starts with nvidia but doesn't match the pattern, it's not a PyTorch package
+        return False
+
+    # Check for other PyTorch-related patterns
+    # Note: 'triton' is now in the explicit set, but keeping for backward compatibility
+    # Removed 'cuda' and 'cudnn' as standalone patterns to avoid false positives
+    if 'torchtext' in package_lower or 'torchaudio' in package_lower:
+        return True
+
+    return False
+
+
+def get_pytorch_index_url(torch_version: str, cuda_torch_version: str | None = None) -> str | None:
+    """Determine the appropriate PyTorch index URL based on the installed torch version."""
+    if not torch_version:
+        return None
+
+    # Parse the torch version to determine the index
+    if '+cpu' in torch_version:
+        return "https://download.pytorch.org/whl/cpu"
+
+    # Extract CUDA version from torch version string
+    cuda_match = re.search(r'\+cu(\d+)', torch_version)
+    if cuda_match:
+        cuda_ver = cuda_match.group(1)
+
+        # Check if it's a nightly/dev version
+        if 'dev' in torch_version or 'nightly' in torch_version:
+            return f"https://download.pytorch.org/whl/nightly/cu{cuda_ver}"
+        else:
+            return f"https://download.pytorch.org/whl/cu{cuda_ver}"
+
+    # Fallback: use the detected CUDA version
+    if cuda_torch_version:
+        # Remove dots from version (12.8 -> 128)
+        cuda_ver = cuda_torch_version.replace('.', '')
+
+        if 'dev' in torch_version or 'nightly' in torch_version:
+            return f"https://download.pytorch.org/whl/nightly/cu{cuda_ver}"
+        else:
+            return f"https://download.pytorch.org/whl/cu{cuda_ver}"
+
+    # If no CUDA info found, assume CPU
+    return "https://download.pytorch.org/whl/cpu"
+
+
+def normalize_package_name(package: str) -> str:
+    """Normalize package name for comparison."""
+    # Handle packages with extras like torch[cuda]
+    if '[' in package:
+        package = package.split('[')[0]
+    return package.strip().lower()

comfygit_core/utils/workflow_hash.py

@@ -0,0 +1,90 @@
+"""Workflow content hashing for cache invalidation.
+
+Provides content-based hashing of workflow JSON with normalization
+to ignore volatile fields like UI state and random seeds.
+"""
+import copy
+import json
+from pathlib import Path
+
+import blake3
+
+
+def compute_workflow_hash(workflow_path: Path) -> str:
+    """Compute content hash for a workflow file.
+
+    Uses blake3 for fast hashing and normalization to ignore
+    volatile fields (UI state, random seeds, etc.).
+
+    Args:
+        workflow_path: Path to workflow JSON file
+
+    Returns:
+        16-character hex hash string (64-bit)
+
+    Examples:
+        >>> compute_workflow_hash(Path("my_workflow.json"))
+        "a1b2c3d4e5f6g7h8"
+    """
+    # Note: Using direct json.load() rather than WorkflowRepository for performance
+    # and separation of concerns (hashing != parsing). This is intentional.
+    # Load workflow JSON
+    with open(workflow_path, 'r', encoding='utf-8') as f:
+        workflow = json.load(f)
+
+    # Normalize to remove volatile fields
+    normalized = normalize_workflow(workflow)
+
+    # Serialize with sorted keys for determinism
+    normalized_json = json.dumps(normalized, sort_keys=True, separators=(',', ':'))
+
+    # Compute blake3 hash
+    hasher = blake3.blake3()
+    hasher.update(normalized_json.encode('utf-8'))
+
+    # Return first 16 hex chars (64-bit hash)
+    return hasher.hexdigest()[:16]
+
+def normalize_workflow(workflow: dict) -> dict:
+    """Remove volatile fields that don't affect workflow functionality.
+
+    Strips:
+    - UI state (extra.ds - pan/zoom)
+    - Frontend version (extra.frontendVersion)
+    - Revision counter (revision)
+    - Auto-generated seeds (when randomize/increment mode is set)
+
+    Args:
+        workflow: Raw workflow dict
+
+    Returns:
+        Normalized workflow dict
+    """
+    normalized = copy.deepcopy(workflow)
+
+    # Remove UI state fields
+    if 'extra' in normalized:
+        normalized['extra'].pop('ds', None)  # Pan/zoom state
+        normalized['extra'].pop('frontendVersion', None)  # Frontend version
+
+    # Remove revision counter
+    normalized.pop('revision', None)
+
+    # Normalize nodes - remove auto-generated seed values when randomize is set
+    if 'nodes' in normalized:
+        for node in normalized['nodes']:
+            if isinstance(node, dict):
+                node_type = node.get('type', '')
+
+                # For sampler nodes with randomize mode, normalize seed to fixed value
+                if node_type in ('KSampler', 'KSamplerAdvanced', 'SamplerCustom'):
+                    # widgets_values format: [seed, control_after_generate, steps, cfg, ...]
+                    widgets_values = node.get('widgets_values', [])
+                    if len(widgets_values) >= 2 and widgets_values[1] in ('randomize', 'increment'):
+                        widgets_values[0] = 0  # Normalize to fixed value
+
+                    api_widget_values = node.get('api_widget_values', [])
+                    if len(api_widget_values) >= 2 and api_widget_values[1] in ('randomize', 'increment'):
+                        api_widget_values[0] = 0  # Normalize to fixed value
+
+    return normalized

comfygit_core/validation/resolution_tester.py

@@ -0,0 +1,297 @@
+"""Resolution testing utility for dependency conflict detection.
+
+This module provides utilities for testing if dependency resolution will succeed
+without actually modifying the environment. Used for pre-flight checks.
+"""
+
+import shutil
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from ..integrations.uv_command import UVCommand
+from ..logging.logging_config import get_logger
+from ..managers.pyproject_manager import PyprojectManager
+from ..models.exceptions import CDPyprojectError, UVCommandError
+from ..utils.conflict_parser import parse_uv_conflicts, parse_uv_resolution
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class ResolutionResult:
+    """Result of dependency resolution attempt."""
+
+    success: bool
+    conflicts: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    resolved_packages: dict[str, str] = field(default_factory=dict)  # name -> version
+    stderr: str = ""  # Raw UV stderr for verbose mode and enhanced error messages
+
+
+class ResolutionTester:
+    """Test dependency resolution without making actual changes."""
+
+    def __init__(self, workspace_path: Path):
+        """Initialize the resolution tester.
+
+        Args:
+            workspace_path: Path to ComfyDock workspace
+        """
+        self.workspace_path = workspace_path
+        self.uv_cache_path = workspace_path / "uv_cache"
+        self.uv_python_path = workspace_path / "uv" / "python"
+        self.logger = logger
+
+    def test_resolution(
+        self, pyproject_path: Path, python_version: str | None = None
+    ) -> ResolutionResult:
+        """Test if a pyproject.toml will resolve successfully.
+
+        Args:
+            pyproject_path: Path to pyproject.toml to test
+            python_version: Optional Python version to test with
+
+        Returns:
+            ResolutionResult with success status and any conflicts
+        """
+        result = ResolutionResult(success=False)
+
+        if not pyproject_path.exists():
+            result.warnings.append(f"pyproject.toml not found: {pyproject_path}")
+            return result
+
+        self.logger.debug(f"Testing resolution for pyproject at {pyproject_path}")
+
+        try:
+            # Create a temporary directory for resolution testing
+            with tempfile.TemporaryDirectory() as temp_dir:
+                temp_path = Path(temp_dir)
+
+                # Copy pyproject.toml to temp location
+                temp_pyproject = temp_path / "pyproject.toml"
+                shutil.copy2(pyproject_path, temp_pyproject)
+
+                # Create UV command for temp directory
+                uv = UVCommand(
+                    project_env=temp_path / ".venv",
+                    cache_dir=self.uv_cache_path,
+                    python_install_dir=self.uv_python_path,
+                    cwd=temp_path,
+                )
+
+                # Try to resolve dependencies (quiet for background testing)
+                try:
+                    resolution_result = uv.sync(all_groups=True, dry_run=True)
+                    resolution_output = resolution_result.stdout
+                except UVCommandError as e:
+                    # Log full UV error details for debugging
+                    self.logger.error(f"UV resolution test failed")
+                    if e.stderr:
+                        self.logger.error(f"UV stderr:\n{e.stderr}")
+                    if e.stdout:
+                        self.logger.debug(f"UV stdout:\n{e.stdout}")
+
+                    # Store raw stderr for verbose mode
+                    error_text = e.stderr or str(e)
+                    result.stderr = error_text
+
+                    # Try to extract structured conflicts from stderr
+                    conflicts = parse_uv_conflicts(error_text)
+                    if conflicts:
+                        result.conflicts.extend(conflicts)
+                    else:
+                        # Fallback: Add concise error from stderr
+                        if e.stderr:
+                            # Extract key error lines from stderr
+                            stderr_lines = [l.strip() for l in e.stderr.strip().split('\n') if l.strip()]
+                            # Find the main error message (usually has × or ERROR:)
+                            error_line = next((l for l in stderr_lines if '×' in l or 'ERROR:' in l.upper()), None)
+                            if error_line:
+                                result.warnings.append(error_line[:300])
+                            else:
+                                # Use last non-empty line as fallback
+                                result.warnings.append(stderr_lines[-1][:300] if stderr_lines else str(e))
+                        else:
+                            result.warnings.append(f"Resolution failed: {str(e)}")
+
+                    return result
+                except Exception as e:
+                    # Non-UV errors
+                    self.logger.error(f"Unexpected error during resolution test: {e}")
+                    result.warnings.append(f"Resolution test error: {str(e)[:300]}")
+                    return result
+
+                logger.debug(f"Resolution output: {resolution_output}")
+
+                result.success = True
+                if resolution_output:
+                    # Parse resolution output to get package versions
+                    result.resolved_packages = parse_uv_resolution(resolution_output)
+                    self.logger.debug(
+                        f"Resolution successful, {len(result.resolved_packages)} packages"
+                    )
+
+        except Exception as e:
+            self.logger.error(f"Error during resolution test: {e}")
+            result.warnings.append(f"Could not test resolution: {str(e)}")
+
+        return result
+
+    def test_with_additions(
+        self,
+        base_pyproject: Path,
+        additional_deps: list[str],
+        group_name: str | None = None,
+    ) -> ResolutionResult:
+        """Test resolution with additional dependencies added.
+
+        Useful for testing if adding new packages will cause conflicts
+        before actually adding them.
+
+        Args:
+            base_pyproject: Base pyproject.toml path
+            additional_deps: List of additional dependencies to test
+            group_name: Optional dependency group to add to
+
+        Returns:
+            ResolutionResult with success status and any conflicts
+        """
+        result = ResolutionResult(success=False)
+
+        if not base_pyproject.exists():
+            result.warnings.append(f"Base pyproject.toml not found: {base_pyproject}")
+            return result
+
+        # Log what we're testing
+        deps_preview = ', '.join(additional_deps[:3])
+        if len(additional_deps) > 3:
+            deps_preview += f'... (+{len(additional_deps) - 3} more)'
+        self.logger.debug(f"Testing additions: {deps_preview} to group '{group_name or 'main'}'")
+
+        try:
+            # Create temporary directory for testing
+            with tempfile.TemporaryDirectory() as temp_dir:
+                temp_path = Path(temp_dir)
+                temp_pyproject = temp_path / "pyproject.toml"
+
+                # Copy base pyproject
+                shutil.copy2(base_pyproject, temp_pyproject)
+
+                # Add the additional dependencies
+                manager = PyprojectManager(temp_pyproject)
+
+                if group_name:
+                    # Add to dependency group
+                    try:
+                        manager.dependencies.add_to_group(group_name, additional_deps)
+                    except CDPyprojectError as e:
+                        result.warnings.append(f"Failed to add to group: {e}")
+                        return result
+                else:
+                    # Add to main dependencies
+                    config = manager.load()
+                    if "project" not in config:
+                        config["project"] = {}
+                    if "dependencies" not in config["project"]:
+                        config["project"]["dependencies"] = []
+
+                    config["project"]["dependencies"].extend(additional_deps)
+                    manager.save(config)
+
+                # Test the modified pyproject
+                return self.test_resolution(temp_pyproject)
+
+        except Exception as e:
+            self.logger.error(f"Error testing with additions: {e}")
+            result.warnings.append(f"Could not test additions: {str(e)}")
+            return result
+
+    def test_node_addition(
+        self, env_path: Path, node_name: str, requirements: list[str]
+    ) -> ResolutionResult:
+        """Test if adding a node with requirements will cause conflicts.
+
+        Args:
+            env_path: Environment path
+            node_name: Name of the node being added
+            requirements: List of requirements from the node
+
+        Returns:
+            ResolutionResult with success status and any conflicts
+        """
+        # Check both main and staged pyproject
+        staged_pyproject = env_path / ".cec" / "pyproject.toml"
+        main_pyproject = env_path / "pyproject.toml"
+
+        # Use staged if exists, otherwise main
+        base_pyproject = (
+            staged_pyproject if staged_pyproject.exists() else main_pyproject
+        )
+
+        if not base_pyproject.exists():
+            # No pyproject yet, test with just the requirements
+            with tempfile.TemporaryDirectory() as temp_dir:
+                temp_path = Path(temp_dir)
+                temp_pyproject = temp_path / "pyproject.toml"
+
+                # Create minimal pyproject
+                manager = PyprojectManager(temp_pyproject)
+                config = {
+                    "project": {
+                        "name": "test-env",
+                        "version": "0.1.0",
+                        "dependencies": requirements,
+                    }
+                }
+                manager.save(config)
+
+                return self.test_resolution(temp_pyproject)
+
+        # Test with additions to existing pyproject
+        group_name = node_name.lower().replace("-", "_").replace(" ", "_")
+        return self.test_with_additions(base_pyproject, requirements, group_name)
+
+
+    def format_conflicts(self, result: ResolutionResult, verbose: bool = False) -> str:
+        """Format resolution conflicts for display.
+
+        Args:
+            result: ResolutionResult to format
+            verbose: Whether to show all conflicts or just top 3
+
+        Returns:
+            Formatted string for display
+        """
+        if result.success:
+            return "✓ No dependency conflicts detected"
+
+        lines = []
+
+        # Show conflicts
+        if result.conflicts:
+            lines.append("⚠️  Dependency conflicts detected:")
+
+            # Filter out the main error line if it's in conflicts
+            display_conflicts = [
+                c for c in result.conflicts if not c.startswith("Resolution failed")
+            ]
+
+            limit = (
+                len(display_conflicts) if verbose else min(3, len(display_conflicts))
+            )
+            for conflict in display_conflicts[:limit]:
+                lines.append(f"  • {conflict}")
+
+            if not verbose and len(display_conflicts) > 3:
+                lines.append(f"  ... and {len(display_conflicts) - 3} more conflicts")
+
+        # Show warnings
+        if result.warnings:
+            if lines:
+                lines.append("")
+            lines.append("⚠️ Warnings:")
+            for warning in result.warnings:
+                lines.append(f"  • {warning}")
+
+        return "\n".join(lines)