comfygit-core 0.2.0__py3-none-any.whl

comfygit_core/utils/input_signature.py

@@ -0,0 +1,145 @@
+"""Input signature utilities for node version resolution."""
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import TYPE_CHECKING, Any, Dict, List
+
+if TYPE_CHECKING:
+    from comfygit_core.models.workflow import NodeInput
+
+from ..logging.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def normalize_registry_inputs(input_types_json: str) -> str:
+    """Normalize input types from registry metadata.
+
+    Args:
+        input_types_json: JSON string like '{"required":{"mask":["MASK"],"scale":["FLOAT",{"default":1}]}}'
+
+    Returns:
+        Canonical input signature string
+    """
+    try:
+        parsed = json.loads(input_types_json)
+        normalized = {}
+
+        # Process required and optional inputs
+        for category in ["required", "optional"]:
+            if category in parsed:
+                for name, type_info in parsed[category].items():
+                    # type_info patterns:
+                    # - ["TYPE"] or ["TYPE", {...constraints}] for simple types
+                    # - [[...options]] or [[...options], {...}] for COMBO/choice fields
+                    if isinstance(type_info, list) and len(type_info) > 0:
+                        first_elem = type_info[0]
+                        # Check if first element is a list (COMBO type)
+                        if isinstance(first_elem, list):
+                            normalized[name] = "COMBO"
+                        elif isinstance(first_elem, str):
+                            normalized[name] = first_elem
+                        else:
+                            logger.warning(f"Unexpected first element type for {name}: {type(first_elem)}")
+                            continue
+                    elif isinstance(type_info, str):
+                        normalized[name] = type_info
+                    else:
+                        logger.warning(f"Unexpected type_info format for {name}: {type_info}")
+                        continue
+
+        return _create_canonical_signature(normalized)
+
+    except (json.JSONDecodeError, KeyError, TypeError) as e:
+        logger.warning(f"Failed to parse registry input types: {e}")
+        return ""
+
+
+def normalize_workflow_inputs(inputs: List[NodeInput]) -> str:
+    """Normalize input types from workflow node definition.
+
+    Args:
+        inputs: List of NodeInput dataclass instances with name and type attributes
+
+    Returns:
+        Canonical input signature string
+    """
+    normalized = {}
+
+    for input_def in inputs:
+        # Handle NodeInput dataclass (has attributes) or dict (has keys)
+        if hasattr(input_def, 'name') and hasattr(input_def, 'type'):
+            # NodeInput dataclass
+            name = input_def.name
+            input_type = input_def.type
+        elif isinstance(input_def, dict):
+            # Legacy dict format (for backwards compatibility)
+            name = input_def.get('name')
+            input_type = input_def.get('type')
+        else:
+            logger.warning(f"Unexpected input format: {type(input_def)}")
+            continue
+
+        if name and input_type:
+            normalized[name] = input_type
+
+    return _create_canonical_signature(normalized)
+
+
+def _create_canonical_signature(inputs: Dict[str, str]) -> str:
+    """Create canonical signature from normalized inputs.
+
+    Args:
+        inputs: Dictionary of {input_name: input_type}
+
+    Returns:
+        Canonical signature string
+    """
+    if not inputs:
+        return ""
+
+    # Sort by name for deterministic ordering
+    sorted_inputs = sorted(inputs.items())
+
+    # Create canonical string: "name1:TYPE1|name2:TYPE2"
+    canonical = "|".join([f"{name}:{type_}" for name, type_ in sorted_inputs])
+
+    return canonical
+
+
+def hash_signature(signature: str) -> str:
+    """Create short hash of input signature.
+
+    Args:
+        signature: Canonical signature string
+
+    Returns:
+        8-character hash
+    """
+    if not signature:
+        return "_"  # Special marker for empty/unknown signatures
+
+    return hashlib.sha1(signature.encode()).hexdigest()[:8]
+
+
+def create_node_key(node_type: str, inputs_signature: str) -> str:
+    """Create compound key for node lookup.
+
+    Args:
+        node_type: Node class type name
+        inputs_signature: Canonical input signature or hash
+
+    Returns:
+        Compound key like "NodeType::hash1234"
+    """
+    if not inputs_signature or inputs_signature == "_":
+        return f"{node_type}::_"
+
+    # If signature is already a hash (8 chars), use it. Otherwise hash it.
+    if len(inputs_signature) == 8 and all(c in '0123456789abcdef' for c in inputs_signature):
+        hash_part = inputs_signature
+    else:
+        hash_part = hash_signature(inputs_signature)
+
+    return f"{node_type}::{hash_part}"

comfygit_core/utils/model_categories.py

@@ -0,0 +1,52 @@
+"""Utility functions for determining model categories from filesystem paths."""
+
+from pathlib import Path
+
+from ..configs.comfyui_models import COMFYUI_MODELS_CONFIG
+
+
+def get_model_category(relative_path: str) -> str:
+    """Determine model category from relative path.
+
+    Extracts the first directory component from the relative path and checks
+    if it matches a standard ComfyUI model directory. If not found in the
+    standard directories, returns 'unknown' to indicate a custom directory.
+
+    Args:
+        relative_path: Path relative to models directory (e.g., "checkpoints/sd_xl.safetensors")
+
+    Returns:
+        Category name (e.g., "checkpoints", "loras", "vae") or "unknown"
+
+    Examples:
+        >>> get_model_category("checkpoints/sd_xl_base.safetensors")
+        'checkpoints'
+        >>> get_model_category("loras/detail_tweaker.safetensors")
+        'loras'
+        >>> get_model_category("custom_nodes/my-node/models/special.pt")
+        'unknown'
+        >>> get_model_category("model.safetensors")
+        'unknown'
+    """
+    if not relative_path:
+        return "unknown"
+
+    # Normalize path and extract first component
+    normalized_path = Path(relative_path).as_posix()
+    parts = normalized_path.split('/')
+
+    if not parts or not parts[0]:
+        return "unknown"
+
+    # Get first directory component (lowercase for case-insensitive matching)
+    first_dir = parts[0].lower()
+
+    # Check against standard directories
+    standard_dirs = COMFYUI_MODELS_CONFIG.get('standard_directories', [])
+
+    # Case-insensitive match
+    for std_dir in standard_dirs:
+        if first_dir == std_dir.lower():
+            return std_dir
+
+    return "unknown"

comfygit_core/utils/pytorch.py

@@ -0,0 +1,71 @@
+"""PyTorch-specific utilities for backend detection and index URL generation."""
+
+from ..constants import PYTORCH_INDEX_BASE_URL
+
+
+def get_pytorch_index_url(backend: str) -> str:
+    """Generate PyTorch index URL for any backend.
+
+    PyTorch uses a consistent URL pattern for all backends:
+    https://download.pytorch.org/whl/{backend}
+
+    This works for:
+    - CPU: cpu
+    - CUDA: cu118, cu121, cu124, cu126, cu128, cu130, etc.
+    - ROCm: rocm6.2, rocm6.3, rocm6.4, etc.
+    - Intel XPU: xpu
+
+    Args:
+        backend: Backend identifier (e.g., 'cu128', 'rocm6.3', 'cpu')
+
+    Returns:
+        Full index URL for the backend
+
+    Examples:
+        >>> get_pytorch_index_url("cu128")
+        'https://download.pytorch.org/whl/cu128'
+        >>> get_pytorch_index_url("rocm6.3")
+        'https://download.pytorch.org/whl/rocm6.3'
+    """
+    return f"{PYTORCH_INDEX_BASE_URL}/{backend}"
+
+
+def extract_backend_from_version(version: str) -> str | None:
+    """Extract backend from PyTorch version string.
+
+    PyTorch versions with specific backends use the format:
+    {version}+{backend} (e.g., '2.9.0+cu128')
+
+    CPU-only builds may omit the backend suffix on some platforms.
+
+    Args:
+        version: Version string (e.g., '2.9.0+cu128', '2.6.0')
+
+    Returns:
+        Backend string (e.g., 'cu128', 'rocm6.3') or None if no backend suffix
+
+    Examples:
+        >>> extract_backend_from_version("2.9.0+cu128")
+        'cu128'
+        >>> extract_backend_from_version("2.9.0")
+        None
+    """
+    if '+' in version:
+        return version.split('+')[1]
+    return None
+
+
+def extract_pip_show_package_version(pip_show_output: str) -> str | None:
+    """Extract version from pip show output.
+
+    Args:
+        pip_show_output: Output from 'uv pip show package'
+
+    Returns:
+        Version string (e.g., '2.6.0+cu128') or None if not found
+    """
+    import re
+    match = re.search(r'^Version:\s*(.+)$', pip_show_output, re.MULTILINE)
+    if match:
+        return match.group(1).strip()
+    return None

comfygit_core/utils/requirements.py

@@ -0,0 +1,211 @@
+"""Requirements parsing utilities."""
+
+from pathlib import Path
+
+import requirements
+import tomlkit
+
+from ..logging.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def parse_requirements_file(requirements_path: Path) -> dict[str, list[str]]:
+    """Parse a requirements.txt file and return package requirements."""
+    parsed_requirements = {}
+
+    if not requirements_path.exists():
+        return parsed_requirements
+
+    try:
+        with open(requirements_path, encoding='utf-8') as f:
+            original_lines = f.readlines()
+
+        # Try iterative parsing to isolate and remove problematic lines
+        valid_lines = _get_valid_requirements_lines(original_lines, requirements_path)
+
+        # Parse the valid lines
+        if valid_lines:
+            valid_content = '\n'.join(valid_lines)
+            try:
+                for req in requirements.parse(valid_content):
+                    # Only process regular package requirements (not VCS, local files, etc.)
+                    if req.name and req.specifier:
+                        package_name = req.name.lower()
+
+                        if package_name not in parsed_requirements:
+                            parsed_requirements[package_name] = []
+
+                        # Convert specs to version constraints
+                        if req.specs:
+                            # Join all version specs into a single constraint string
+                            version_spec = ",".join([f"{op}{ver}" for op, ver in req.specs])
+                            parsed_requirements[package_name].append(version_spec)
+                        else:
+                            parsed_requirements[package_name].append("")
+
+                    elif req.name and not req.specifier:
+                        # Package without version constraints
+                        package_name = req.name.lower()
+                        if package_name not in parsed_requirements:
+                            parsed_requirements[package_name] = []
+                        parsed_requirements[package_name].append("")
+
+                    # Skip VCS requirements, local files, etc. - they'll be handled elsewhere
+                    elif req.vcs or req.local_file or req.uri:
+                        logger.debug(f"Skipping non-standard requirement: {req.line}")
+
+            except Exception as e:
+                logger.error(f"Failed to parse even filtered requirements from {requirements_path}: {e}")
+
+    except Exception as e:
+        logger.error(f"Error reading {requirements_path}: {e}")
+
+    return parsed_requirements
+
+
+def _get_valid_requirements_lines(original_lines: list[str], requirements_path: Path) -> list[str]:
+    """
+    Iteratively remove problematic lines from requirements until we can parse successfully.
+    Returns a list of valid requirement lines.
+    """
+    # Start with all non-empty, non-comment lines
+    candidate_lines = []
+    for line in original_lines:
+        line = line.strip()
+        if line and not line.startswith('#') and not line.startswith('-'):
+            candidate_lines.append(line)
+
+    if not candidate_lines:
+        return []
+
+    max_attempts = len(candidate_lines)
+    removed_lines = []
+
+    for _ in range(max_attempts):
+        try:
+            # Try to parse current candidate lines
+            test_content = '\n'.join(candidate_lines)
+            list(requirements.parse_requirements_file(test_content))  # This will raise if there's an error
+
+            # If we get here, parsing succeeded
+            if removed_lines:
+                logger.info(f"Successfully parsed {requirements_path} after removing {len(removed_lines)} problematic lines")
+                for removed in removed_lines:
+                    logger.debug(f"  Removed: {removed}")
+
+            return candidate_lines
+
+        except Exception:
+            # Parse failed, try to identify the problematic line
+            problematic_line = None
+
+            # Try to extract line content from error message or find it by testing each line
+            for i, line in enumerate(candidate_lines):
+                try:
+                    list(requirements.parse(line))
+                except Exception:
+                    # This line causes an error
+                    problematic_line = line
+                    candidate_lines.pop(i)
+                    removed_lines.append(line)
+                    logger.warning(f"Removed problematic requirement line: {line}")
+                    break
+
+            if problematic_line is None:
+                # Couldn't identify the specific line, remove the first line and try again
+                if candidate_lines:
+                    removed_line = candidate_lines.pop(0)
+                    removed_lines.append(removed_line)
+                    logger.warning(f"Could not identify specific problematic line, removed: {removed_line}")
+                else:
+                    break
+
+    # If we exhausted all attempts
+    if removed_lines:
+        logger.warning(f"Could not parse {requirements_path} even after removing all lines")
+
+    return candidate_lines
+
+
+def parse_pyproject_toml(pyproject_path: Path) -> dict | None:
+    """Parse pyproject.toml file and extract project information."""
+    try:
+        with open(pyproject_path, encoding='utf-8') as f:
+            data = tomlkit.load(f)
+
+        # Extract project information
+        project_info = {}
+
+        # Check different possible locations for project metadata
+        if 'project' in data:
+            project = data['project']
+            project_info['name'] = project.get('name', '')
+            project_info['version'] = project.get('version', '')
+            project_info['description'] = project.get('description', '')
+            project_info['authors'] = project.get('authors', [])
+            project_info['urls'] = project.get('urls', {})
+
+        # Also check tool.poetry section (for Poetry projects)
+        if 'tool' in data and 'poetry' in data['tool']:
+            poetry = data['tool']['poetry']
+            if not project_info.get('name'):
+                project_info['name'] = poetry.get('name', '')
+            if not project_info.get('version'):
+                project_info['version'] = poetry.get('version', '')
+            if not project_info.get('description'):
+                project_info['description'] = poetry.get('description', '')
+            if not project_info.get('authors'):
+                project_info['authors'] = poetry.get('authors', [])
+
+        # Extract dependencies if present
+        if 'dependencies' in data.get('project', {}):
+            project_info['dependencies'] = data['project']['dependencies']
+        elif 'tool' in data and 'poetry' in data['tool'] and 'dependencies' in data['tool']['poetry']:
+            project_info['dependencies'] = data['tool']['poetry']['dependencies']
+
+        return project_info if project_info.get('name') else None
+
+    except Exception as e:
+        logger.error(f"Error parsing pyproject.toml: {e}")
+        return None
+
+
+def save_requirements_txt(requirements: dict[str, str], system_info: dict, comfyui_path: Path):
+    """Save the resolved requirements to a requirements.txt file."""
+    req_path = Path("comfyui_requirements.txt")
+
+    with open(req_path, 'w', encoding='utf-8') as f:
+        f.write("# ComfyUI Migration Requirements\n")
+        f.write(f"# Generated from: {comfyui_path}\n")
+        f.write(f"# Python version: {system_info.get('python_version')}\n")
+        if system_info.get('cuda_version'):
+            f.write(f"# CUDA version: {system_info.get('cuda_version')}\n")
+        if system_info.get('torch_version'):
+            f.write(f"# PyTorch version: {system_info.get('torch_version')}\n")
+        f.write("\n")
+        f.write("# NOTE: PyTorch packages are handled separately in comfyui_migration.json\n")
+        f.write("# Install with: pip install -r comfyui_requirements.txt\n")
+        f.write("\n")
+
+        # Sort packages for consistency
+        for package in sorted(requirements.keys()):
+            version = requirements[package]
+            if version:
+                f.write(f"{package}=={version}\n")
+            else:
+                f.write(f"{package}\n")
+
+        # Add editable and git requirements at the end
+        if system_info.get('editable_installs'):
+            f.write("\n# Editable installs\n")
+            for install in system_info['editable_installs']:
+                f.write(f"{install}\n")
+
+        if system_info.get('git_requirements'):
+            f.write("\n# Git requirements\n")
+            for req in system_info['git_requirements']:
+                f.write(f"{req}\n")
+
+    logger.info(f"Requirements saved to {req_path}")
+    logger.info(f"Requirements saved to {req_path}")