comfygit-core 0.2.0__py3-none-any.whl

comfygit_core/utils/conflict_parser.py

@@ -0,0 +1,232 @@
+"""UV dependency conflict parsing utilities.
+
+This module provides utilities for parsing and simplifying UV (uv) package manager
+error messages, particularly dependency conflicts.
+"""
+
+import re
+
+from ..logging.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def parse_uv_conflicts(error_text: str, max_lines: int = 3) -> list[str]:
+    """Extract specific conflict messages from UV error output.
+    
+    Looks for patterns like:
+    - "X and Y are incompatible"
+    - "X depends on Y but Z needs different version"
+    - Conclusion statements about incompatibilities
+    
+    Args:
+        error_text: Raw UV error output
+        max_lines: Maximum number of conflict messages to return
+        
+    Returns:
+        List of simplified conflict messages
+    """
+    conflicts = []
+
+    if not error_text:
+        return conflicts
+
+    # Pattern: "X and Y are incompatible"
+    incompatible_pattern = r"(\S+) and (\S+) are incompatible"
+    for match in re.finditer(incompatible_pattern, error_text):
+        pkg1, pkg2 = match.groups()
+        # Clean up package names (remove version specs)
+        pkg1_clean = _clean_package_name(pkg1)
+        pkg2_clean = _clean_package_name(pkg2)
+        conflicts.append(f"{pkg1_clean} conflicts with {pkg2_clean}")
+
+    # Pattern: "X depends on Y but Z needs different version"
+    depends_pattern = r"(\S+) depends on (\S+)"
+    dependencies = {}
+    for match in re.finditer(depends_pattern, error_text):
+        pkg, dep = match.groups()
+        if pkg not in dependencies:
+            dependencies[pkg] = []
+        dependencies[pkg].append(dep)
+
+    # If we found specific conflicts, use those
+    if conflicts:
+        return conflicts[:max_lines]  # Limit to top 3 for brevity
+
+    # Otherwise, try to extract conclusion lines
+    lines = error_text.split('\n')
+    for line in lines:
+        line = line.strip()
+        # Skip empty lines and hints
+        if not line or line.startswith('hint:'):
+            continue
+        # Look for conclusion lines
+        if 'conclude that' in line and 'incompatible' in line:
+            # Extract the key part
+            if 'we can conclude that' in line:
+                conclusion = line.split('we can conclude that')[1].strip()
+                conflicts.append(conclusion)
+
+    return conflicts[:max_lines]  # Limit output
+
+
+def parse_uv_resolution(output: str | None) -> dict[str, str]:
+    """Parse UV resolution output to extract package versions.
+    
+    Args:
+        output: UV resolution output text
+        
+    Returns:
+        Dict mapping package names to resolved versions
+    """
+    packages = {}
+
+    if not output:
+        return packages
+
+    # UV resolution output format varies, this is a simplified parser
+    # Look for patterns like: package==version
+    for line in output.split('\n'):
+        line = line.strip()
+        if '==' in line:
+            parts = line.split('==')
+            if len(parts) == 2:
+                name = parts[0].strip()
+                version = parts[1].strip()
+                # Clean up the name (remove any prefixes)
+                name = _clean_package_name(name)
+                packages[name] = version
+
+    return packages
+
+
+def simplify_conflict_message(full_error: str, max_lines: int = 3) -> list[str]:
+    """Simplify a full UV conflict error into user-friendly messages.
+    
+    Args:
+        full_error: Complete UV error message
+        max_lines: Maximum number of simplified messages to return
+        
+    Returns:
+        List of simplified, user-friendly conflict descriptions
+    """
+    # First try to parse specific conflicts
+    conflicts = parse_uv_conflicts(full_error)
+    if conflicts:
+        return conflicts[:max_lines]
+
+    # If no specific conflicts found, extract key error lines
+    simplified = []
+    key_phrases = [
+        "incompatible",
+        "conflict",
+        "cannot satisfy",
+        "no solution found",
+        "requires",
+        "depends on"
+    ]
+
+    lines = full_error.split('\n')
+    for line in lines:
+        line = line.strip()
+        if any(phrase in line.lower() for phrase in key_phrases):
+            # Remove UV-specific prefixes
+            line = _clean_error_line(line)
+            if line and line not in simplified:
+                simplified.append(line)
+                if len(simplified) >= max_lines:
+                    break
+
+    return simplified
+
+
+def extract_conflicting_packages(error_text: str) -> list[tuple[str, str]]:
+    """Extract pairs of conflicting packages from UV error.
+    
+    Args:
+        error_text: UV error output
+        
+    Returns:
+        List of tuples (package1, package2) that conflict
+    """
+    pairs = []
+
+    # Look for explicit incompatibility statements
+    pattern = r"(\S+)==[\d\.]+ and (\S+)==[\d\.]+ are incompatible"
+    for match in re.finditer(pattern, error_text):
+        pkg1 = _clean_package_name(match.group(1))
+        pkg2 = _clean_package_name(match.group(2))
+        pairs.append((pkg1, pkg2))
+
+    # Look for version conflict patterns
+    pattern = r"(\S+) requires (\S+)==[\d\.]+.*but.*(\S+) requires (\S+)==[\d\.]+"
+    for match in re.finditer(pattern, error_text):
+        # This pattern suggests pkg1 and pkg3 have conflicting requirements for pkg2/pkg4
+        pkg1 = _clean_package_name(match.group(1))
+        pkg3 = _clean_package_name(match.group(3))
+        if pkg1 != pkg3:
+            pairs.append((pkg1, pkg3))
+
+    # Remove duplicates while preserving order
+    seen = set()
+    unique_pairs = []
+    for pair in pairs:
+        # Normalize order (alphabetical)
+        normalized = tuple(sorted(pair))
+        if normalized not in seen:
+            seen.add(normalized)
+            unique_pairs.append(pair)
+
+    return unique_pairs
+
+
+def _clean_package_name(name: str) -> str:
+    """Clean up a package name by removing version specs and extras.
+    
+    Args:
+        name: Raw package name (might include version specs)
+        
+    Returns:
+        Clean package name
+    """
+    # Remove version specifiers
+    for sep in ['==', '>=', '<=', '>', '<', '~=', '!=']:
+        if sep in name:
+            name = name.split(sep)[0]
+
+    # Remove extras [extra1,extra2]
+    if '[' in name:
+        name = name.split('[')[0]
+
+    # Remove any remaining whitespace
+    return name.strip()
+
+
+def _clean_error_line(line: str) -> str:
+    """Clean up an error line for display.
+    
+    Args:
+        line: Raw error line
+        
+    Returns:
+        Cleaned error line
+    """
+    # Remove common UV prefixes
+    prefixes_to_remove = [
+        "error:",
+        "Error:",
+        "ERROR:",
+        "  × ",
+        "  │ ",
+        "  ╰─▶ ",
+    ]
+
+    for prefix in prefixes_to_remove:
+        if line.startswith(prefix):
+            line = line[len(prefix):].strip()
+
+    # Truncate very long lines
+    if len(line) > 100:
+        line = line[:97] + "..."
+
+    return line

comfygit_core/utils/dependency_parser.py

@@ -0,0 +1,231 @@
+"""Dependency parsing utilities for pyproject.toml files.
+
+This module provides utilities for parsing and comparing Python package dependencies
+from pyproject.toml files, including support for UV dependency groups.
+"""
+
+import re
+
+from ..logging.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def parse_dependency_string(dep_str: str) -> tuple[str, str | None]:
+    """Parse a dependency string like 'numpy>=1.21.0' into name and version.
+    
+    Args:
+        dep_str: Dependency string (e.g., 'numpy>=1.21.0', 'numpy[extra]>=1.21.0')
+        
+    Returns:
+        Tuple of (package_name, version_spec) where version_spec may be None
+    """
+    # Handle various formats: numpy, numpy>=1.21.0, numpy[extra]>=1.21.0
+    match = re.match(r'^([a-zA-Z0-9_-]+)(?:\[.*?\])?(.*)$', dep_str.strip())
+    if match:
+        name = match.group(1)
+        version_spec = match.group(2).strip() if match.group(2) else None
+        return name, version_spec
+
+    return dep_str.strip(), None
+
+
+def extract_all_dependencies(pyproject_data: dict) -> dict[str, dict]:
+    """Extract all dependencies from pyproject.toml including groups.
+    
+    When a package appears in multiple places, we track all occurrences
+    and use the most restrictive constraint as the effective one.
+    
+    Args:
+        pyproject_data: Parsed pyproject.toml data
+        
+    Returns:
+        Dict mapping package names to their info (version, source)
+    """
+    deps = {}
+
+    # Track all sources and versions for each package
+    package_occurrences = {}  # name -> [(source, version), ...]
+
+    # Main dependencies
+    if "project" in pyproject_data:
+        for dep_str in pyproject_data["project"].get("dependencies", []):
+            name, version = parse_dependency_string(dep_str)
+            if name not in package_occurrences:
+                package_occurrences[name] = []
+            package_occurrences[name].append(("main", version))
+
+    # Dependency groups (UV format)
+    if "dependency-groups" in pyproject_data:
+        for group_name, group_deps in pyproject_data["dependency-groups"].items():
+            for dep_str in group_deps:
+                name, version = parse_dependency_string(dep_str)
+                if name not in package_occurrences:
+                    package_occurrences[name] = []
+                package_occurrences[name].append((f"group:{group_name}", version))
+
+    # Tool-specific dependencies (for custom nodes)
+    if "tool" in pyproject_data:
+        if "uv" in pyproject_data["tool"]:
+            uv_config = pyproject_data["tool"]["uv"]
+            if "dev-dependencies" in uv_config:
+                for dep_str in uv_config["dev-dependencies"]:
+                    name, version = parse_dependency_string(dep_str)
+                    if name not in package_occurrences:
+                        package_occurrences[name] = []
+                    package_occurrences[name].append(("dev", version))
+
+    # For each package, determine the effective constraint
+    for name, occurrences in package_occurrences.items():
+        # Find the most restrictive version constraint
+        # Priority: exact pins > bounded constraints > lower bounds > unconstrained
+        most_restrictive = None
+        all_sources = []
+
+        for source, version in occurrences:
+            all_sources.append(source)
+            if most_restrictive is None:
+                most_restrictive = version
+            elif version is not None:
+                # Compare constraints - this is simplified
+                # In reality, we'd need proper version parsing
+                if most_restrictive is None:
+                    most_restrictive = version
+                elif "==" in version:  # Exact pin
+                    most_restrictive = version
+                elif "==" not in most_restrictive:
+                    # Prefer the more specific constraint
+                    if len(version) > len(most_restrictive or ""):
+                        most_restrictive = version
+
+        deps[name] = {
+            "version": most_restrictive,
+            "source": ", ".join(set(all_sources))  # Show all sources
+        }
+
+    return deps
+
+
+def is_meaningful_version_change(old_version: str | None,
+                                new_version: str | None) -> bool:
+    """Determine if a version change is meaningful.
+    
+    Rules:
+    - No change if both are None or both are the same
+    - No change if one is None and the other is a lower bound (>=)
+      since unconstrained effectively means "any version"
+    - Change if going from unconstrained to pinned
+    - Change if version numbers actually differ
+    
+    Args:
+        old_version: Previous version constraint
+        new_version: New version constraint
+        
+    Returns:
+        True if the change is meaningful
+    """
+    # Both None or identical - no change
+    if old_version == new_version:
+        return False
+
+    # One is None - check if it's effectively the same
+    if old_version is None and new_version is not None:
+        # Going from unconstrained to constrained
+        # Only meaningful if it's not just a lower bound
+        if new_version.startswith(">="):
+            # Lower bound only - not really a meaningful constraint
+            return False
+        return True
+
+    if new_version is None and old_version is not None:
+        # Going from constrained to unconstrained
+        # Only meaningful if we had a real constraint before
+        if old_version.startswith(">="):
+            # Was just a lower bound - not meaningful
+            return False
+        return True
+
+    # Both have versions - check if they differ meaningfully
+    # This is simplified - a full implementation would parse version specs
+    return old_version != new_version
+
+
+def find_most_restrictive_constraint(constraints: list[str]) -> str | None:
+    """Find the most restrictive version constraint from a list.
+    
+    Priority: exact pins > upper bounds > ranges > lower bounds > unconstrained
+    
+    Args:
+        constraints: List of version constraints
+        
+    Returns:
+        The most restrictive constraint or None
+    """
+    if not constraints:
+        return None
+
+    # Filter out None values
+    valid_constraints = [c for c in constraints if c]
+    if not valid_constraints:
+        return None
+
+    # Look for exact pins first
+    for constraint in valid_constraints:
+        if "==" in constraint:
+            return constraint
+
+    # Look for upper bounds or ranges
+    for constraint in valid_constraints:
+        if "<" in constraint or "," in constraint:
+            return constraint
+
+    # Return any constraint (likely lower bounds)
+    return valid_constraints[0]
+
+
+def compare_dependency_sets(before: dict[str, dict], after: dict[str, dict]) -> dict[str, list]:
+    """Compare two sets of dependencies to find changes.
+    
+    Args:
+        before: Previous dependencies (from git)
+        after: Current dependencies (from file)
+        
+    Returns:
+        Dict with 'added', 'removed', and 'updated' lists
+    """
+    changes = {
+        "added": [],
+        "removed": [],
+        "updated": []
+    }
+
+    all_packages = set(before.keys()) | set(after.keys())
+
+    for pkg in all_packages:
+        if pkg not in before:
+            # New package
+            changes["added"].append({
+                "name": pkg,
+                "version": after[pkg].get("version"),
+                "source": after[pkg].get("source")
+            })
+        elif pkg not in after:
+            # Removed package
+            changes["removed"].append({
+                "name": pkg,
+                "version": before[pkg].get("version")
+            })
+        else:
+            # Check if there's a meaningful change
+            old_version = before[pkg].get("version")
+            new_version = after[pkg].get("version")
+
+            if is_meaningful_version_change(old_version, new_version):
+                changes["updated"].append({
+                    "name": pkg,
+                    "old_version": old_version,
+                    "new_version": new_version,
+                    "source": after[pkg].get("source")
+                })
+
+    return changes

comfygit_core/utils/download.py

@@ -0,0 +1,216 @@
+"""Download and archive extraction utilities."""
+
+import tarfile
+import tempfile
+import urllib.request
+import zipfile
+from pathlib import Path
+
+from ..logging.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def download_and_extract_archive(url: str, target_path: Path) -> None:
+    """Download and extract an archive file with automatic format detection.
+    
+    Args:
+        url: URL of the archive to download
+        target_path: Directory to extract contents to
+        
+    Raises:
+        OSError: If download fails
+        ValueError: If archive format is unsupported or corrupted
+    """
+    temp_file_path = None
+    try:
+        # Download file first
+        temp_file_path = download_file(url)
+        # Extract with format detection
+        extract_archive(temp_file_path, target_path)
+
+    except (OSError, ValueError):
+        # Re-raise download and extraction errors as-is
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error during download/extract: {e}")
+        raise OSError(f"Unexpected error during download/extract: {e}")
+    finally:
+        # Always clean up temp file
+        if temp_file_path and temp_file_path.exists():
+            try:
+                temp_file_path.unlink()
+            except OSError:
+                # Log but don't fail if cleanup fails
+                logger.warning(f"Failed to clean up temp file: {temp_file_path}")
+
+
+def download_file(url: str, suffix: str | None = None) -> Path:
+    """Download a file to a temporary location.
+    
+    Args:
+        url: URL to download from
+        suffix: Optional file suffix for the temp file
+        
+    Returns:
+        Path to downloaded file
+        
+    Raises:
+        OSError: If download fails
+    """
+    try:
+        if not suffix:
+            suffix = Path(url).suffix
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp_file:
+            logger.info(f"Downloading from {url}")
+
+            with urllib.request.urlopen(url) as response:
+                # Read in chunks for large files
+                chunk_size = 8192
+                total_size = 0
+
+                while True:
+                    chunk = response.read(chunk_size)
+                    if not chunk:
+                        break
+                    tmp_file.write(chunk)
+                    total_size += len(chunk)
+
+            tmp_path = Path(tmp_file.name)
+            logger.debug(f"Downloaded {total_size / 1024:.1f} KB to {tmp_path}")
+            return tmp_path
+
+    except Exception as e:
+        logger.error(f"Download failed: {e}")
+        raise OSError(f"Download failed: {e}")
+
+
+def extract_archive(archive_path: Path, target_path: Path) -> None:
+    """Extract an archive with automatic format detection.
+    
+    Tries multiple archive formats until one succeeds:
+    - ZIP
+    - TAR.GZ (gzipped tar)
+    - TAR (plain tar)
+    - TAR.BZ2 (bzip2 tar)
+    
+    Args:
+        archive_path: Path to archive file
+        target_path: Directory to extract to
+        
+    Raises:
+        ValueError: If file is not a supported archive format
+        OSError: If file system operation fails (permissions, disk space, etc.)
+    """
+    # Ensure target directory exists
+    target_path.mkdir(parents=True, exist_ok=True)
+
+    # Try different extraction methods
+    extractors = [
+        (_try_extract_zip, "zip"),
+        (_try_extract_tar_gz, "tar.gz"),
+        (_try_extract_tar, "tar"),
+        (_try_extract_tar_bz2, "tar.bz2"),
+    ]
+
+    extraction_errors = []
+
+    for extractor, format_name in extractors:
+        try:
+            extractor(archive_path, target_path)
+            logger.info(f"Successfully extracted as {format_name} format")
+            return
+        except (zipfile.BadZipFile, tarfile.ReadError):
+            # Expected errors for wrong format, continue trying
+            continue
+        except Exception as e:
+            # Unexpected errors, collect for reporting
+            extraction_errors.append(f"{format_name}: {e}")
+
+    # If nothing worked, log diagnostic info and raise exception
+    _log_extraction_failure(archive_path)
+    if extraction_errors:
+        # Had OS-level errors during extraction attempts
+        error_details = "; ".join(extraction_errors)
+        raise OSError(f"Archive extraction failed due to system errors: {error_details}")
+    else:
+        # No format worked, likely unsupported/corrupted file
+        raise ValueError(f"Unsupported or corrupted archive format: {archive_path}")
+
+
+def _try_extract_zip(archive_path: Path, target_path: Path) -> None:
+    """Try to extract as ZIP archive.
+    
+    Raises:
+        zipfile.BadZipFile: If not a valid ZIP file
+        OSError: If extraction fails
+    """
+    try:
+        with zipfile.ZipFile(archive_path, 'r') as zip_ref:
+            zip_ref.extractall(target_path)
+    except zipfile.BadZipFile:
+        raise
+    except Exception as e:
+        raise OSError(f"ZIP extraction failed: {e}")
+
+
+def _try_extract_tar_gz(archive_path: Path, target_path: Path) -> None:
+    """Try to extract as gzipped TAR archive.
+    
+    Raises:
+        tarfile.ReadError: If not a valid gzipped TAR file
+        OSError: If extraction fails
+    """
+    try:
+        with tarfile.open(archive_path, 'r:gz') as tar:
+            tar.extractall(target_path)
+    except tarfile.ReadError:
+        raise
+    except Exception as e:
+        raise OSError(f"TAR.GZ extraction failed: {e}")
+
+
+def _try_extract_tar(archive_path: Path, target_path: Path) -> None:
+    """Try to extract as plain TAR archive.
+    
+    Raises:
+        tarfile.ReadError: If not a valid TAR file
+        OSError: If extraction fails
+    """
+    try:
+        with tarfile.open(archive_path, 'r:') as tar:
+            tar.extractall(target_path)
+    except tarfile.ReadError:
+        raise
+    except Exception as e:
+        raise OSError(f"TAR extraction failed: {e}")
+
+
+def _try_extract_tar_bz2(archive_path: Path, target_path: Path) -> None:
+    """Try to extract as bzip2 TAR archive.
+    
+    Raises:
+        tarfile.ReadError: If not a valid bzip2 TAR file
+        OSError: If extraction fails
+    """
+    try:
+        with tarfile.open(archive_path, 'r:bz2') as tar:
+            tar.extractall(target_path)
+    except tarfile.ReadError:
+        raise
+    except Exception as e:
+        raise OSError(f"TAR.BZ2 extraction failed: {e}")
+
+
+def _log_extraction_failure(archive_path: Path) -> None:
+    """Log diagnostic information when extraction fails."""
+    logger.error(f"Unable to extract archive: {archive_path}")
+
+    # Read first few bytes for debugging
+    try:
+        with open(archive_path, 'rb') as f:
+            header = f.read(32)
+            logger.debug(f"File header (first 32 bytes): {header}")
+    except Exception:
+        pass