comfy-env 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

comfy_env/packages/__init__.py

@@ -0,0 +1,60 @@
+"""
+Packages layer - Package installation with side effects.
+
+Handles pixi, CUDA wheels, apt packages, and node dependencies.
+"""
+
+from .pixi import (
+    PIXI_VERSION,
+    ensure_pixi,
+    get_pixi_path,
+    get_pixi_python,
+    pixi_install,
+    pixi_run,
+    pixi_clean,
+)
+from .cuda_wheels import (
+    CUDA_WHEELS_INDEX,
+    get_wheel_url,
+    find_available_wheels,
+    get_cuda_torch_mapping,
+)
+from .toml_generator import (
+    generate_pixi_toml,
+    config_to_pixi_dict,
+)
+from .apt import (
+    apt_install,
+    check_apt_packages,
+)
+from .node_dependencies import (
+    install_node_dependencies,
+    clone_node,
+    normalize_repo_url,
+)
+
+__all__ = [
+    # Pixi package manager
+    "PIXI_VERSION",
+    "ensure_pixi",
+    "get_pixi_path",
+    "get_pixi_python",
+    "pixi_install",
+    "pixi_run",
+    "pixi_clean",
+    # CUDA wheels
+    "CUDA_WHEELS_INDEX",
+    "get_wheel_url",
+    "find_available_wheels",
+    "get_cuda_torch_mapping",
+    # TOML generation
+    "generate_pixi_toml",
+    "config_to_pixi_dict",
+    # APT packages
+    "apt_install",
+    "check_apt_packages",
+    # Node dependencies
+    "install_node_dependencies",
+    "clone_node",
+    "normalize_repo_url",
+]

comfy_env/packages/apt.py

@@ -0,0 +1,36 @@
+"""APT package installation (Linux only)."""
+
+import subprocess
+import sys
+from typing import Callable, List
+
+
+def apt_install(packages: List[str], log: Callable[[str], None] = print) -> bool:
+    """Install system packages via apt-get. No-op on non-Linux."""
+    if not packages or sys.platform != "linux":
+        return True
+
+    log(f"Installing apt packages: {packages}")
+
+    subprocess.run(["sudo", "apt-get", "update"], capture_output=True, text=True)
+
+    result = subprocess.run(
+        ["sudo", "apt-get", "install", "-y"] + packages,
+        capture_output=True, text=True
+    )
+    if result.returncode != 0:
+        log(f"Warning: apt-get install failed: {result.stderr[:200]}")
+        return False
+
+    return True
+
+
+def check_apt_packages(packages: List[str]) -> List[str]:
+    """Return list of packages NOT installed."""
+    if sys.platform != "linux":
+        return []
+
+    return [
+        pkg for pkg in packages
+        if subprocess.run(["dpkg", "-s", pkg], capture_output=True).returncode != 0
+    ]

comfy_env/packages/cuda_wheels.py

@@ -0,0 +1,97 @@
+"""CUDA wheels index integration. See: https://pozzettiandrea.github.io/cuda-wheels/"""
+
+import re
+import sys
+import urllib.request
+from typing import List, Optional
+
+CUDA_WHEELS_INDEX = "https://pozzettiandrea.github.io/cuda-wheels/"
+CUDA_TORCH_MAP = {"12.8": "2.8", "12.4": "2.4"}
+
+
+def get_cuda_torch_mapping() -> dict:
+    return CUDA_TORCH_MAP.copy()
+
+
+def get_torch_version_for_cuda(cuda_version: str) -> Optional[str]:
+    return CUDA_TORCH_MAP.get(".".join(cuda_version.split(".")[:2]))
+
+
+def _pkg_variants(package: str) -> List[str]:
+    return [package, package.replace("-", "_"), package.replace("_", "-")]
+
+
+def _platform_tag() -> Optional[str]:
+    if sys.platform.startswith("linux"): return "linux_x86_64"
+    if sys.platform == "win32": return "win_amd64"
+    return None
+
+
+def get_wheel_url(package: str, torch_version: str, cuda_version: str, python_version: str) -> Optional[str]:
+    """Get direct URL to matching wheel from cuda-wheels index."""
+    cuda_short = cuda_version.replace(".", "")[:3]
+    torch_short = torch_version.replace(".", "")[:2]
+    py_tag = f"cp{python_version.replace('.', '')}"
+    platform_tag = _platform_tag()
+
+    local_patterns = [f"+cu{cuda_short}torch{torch_short}", f"+pt{torch_short}cu{cuda_short}"]
+    link_pattern = re.compile(r'href="([^"]+\.whl)"[^>]*>([^<]+)</a>', re.IGNORECASE)
+
+    for pkg_dir in _pkg_variants(package):
+        try:
+            with urllib.request.urlopen(f"{CUDA_WHEELS_INDEX}{pkg_dir}/", timeout=10) as resp:
+                html = resp.read().decode("utf-8")
+        except Exception: continue
+
+        for match in link_pattern.finditer(html):
+            wheel_url, display = match.group(1), match.group(2)
+            if any(p in display for p in local_patterns) and py_tag in display:
+                if platform_tag is None or platform_tag in display:
+                    return wheel_url if wheel_url.startswith("http") else f"{CUDA_WHEELS_INDEX}{pkg_dir}/{wheel_url}"
+    return None
+
+
+def find_available_wheels(package: str) -> List[str]:
+    """List all available wheels for a package."""
+    wheels = []
+    link_pattern = re.compile(r'href="[^"]*?([^"/]+\.whl)"', re.IGNORECASE)
+    for pkg_dir in _pkg_variants(package):
+        try:
+            with urllib.request.urlopen(f"{CUDA_WHEELS_INDEX}{pkg_dir}/", timeout=10) as resp:
+                html = resp.read().decode("utf-8")
+            for match in link_pattern.finditer(html):
+                name = match.group(1).replace("%2B", "+")
+                if name not in wheels: wheels.append(name)
+        except Exception: continue
+    return wheels
+
+
+def find_matching_wheel(package: str, torch_version: str, cuda_version: str) -> Optional[str]:
+    """Find wheel matching CUDA/torch version, return version spec."""
+    cuda_short = cuda_version.replace(".", "")[:3]
+    torch_short = torch_version.replace(".", "")[:2]
+    local_patterns = [f"+cu{cuda_short}torch{torch_short}", f"+pt{torch_short}cu{cuda_short}"]
+    wheel_pattern = re.compile(r'href="[^"]*?([^"/]+\.whl)"', re.IGNORECASE)
+
+    for pkg_dir in _pkg_variants(package):
+        try:
+            with urllib.request.urlopen(f"{CUDA_WHEELS_INDEX}{pkg_dir}/", timeout=10) as resp:
+                html = resp.read().decode("utf-8")
+        except Exception: continue
+
+        best_match = best_version = None
+        for match in wheel_pattern.finditer(html):
+            wheel_name = match.group(1).replace("%2B", "+")
+            for local in local_patterns:
+                if local in wheel_name:
+                    parts = wheel_name.split("-")
+                    if len(parts) >= 2 and (best_version is None or parts[1] > best_version):
+                        best_version = parts[1]
+                        best_match = f"{package}==={parts[1]}"
+                    break
+        if best_match: return best_match
+    return None
+
+
+def get_find_links_urls(package: str) -> List[str]:
+    return [f"{CUDA_WHEELS_INDEX}{p}/" for p in _pkg_variants(package)]

comfy_env/packages/node_dependencies.py

@@ -0,0 +1,77 @@
+"""Node dependency installation - clone ComfyUI nodes from [node_reqs] section."""
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Callable, List, Set, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..config import NodeDependency
+
+
+def normalize_repo_url(repo: str) -> str:
+    if repo.startswith("http"): return repo
+    return f"https://github.com/{repo}"
+
+
+def clone_node(repo: str, name: str, target_dir: Path, log: Callable[[str], None] = print) -> Path:
+    node_path = target_dir / name
+    url = normalize_repo_url(repo)
+    log(f"  Cloning {name}...")
+    result = subprocess.run(["git", "clone", "--depth", "1", url, str(node_path)], capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to clone {url}: {result.stderr.strip()}")
+    return node_path
+
+
+def install_requirements(node_dir: Path, log: Callable[[str], None] = print) -> None:
+    req_file = node_dir / "requirements.txt"
+    if not req_file.exists(): return
+    log(f"  Installing requirements for {node_dir.name}...")
+    cmd = ["uv", "pip", "install", "-r", str(req_file), "--python", sys.executable] if shutil.which("uv") else [sys.executable, "-m", "pip", "install", "-r", str(req_file)]
+    result = subprocess.run(cmd, cwd=node_dir, capture_output=True, text=True)
+    if result.returncode != 0:
+        log(f"  Warning: requirements failed: {result.stderr.strip()[:200]}")
+
+
+def run_install_script(node_dir: Path, log: Callable[[str], None] = print) -> None:
+    install_script = node_dir / "install.py"
+    if install_script.exists():
+        log(f"  Running install.py for {node_dir.name}...")
+        result = subprocess.run([sys.executable, str(install_script)], cwd=node_dir, capture_output=True, text=True)
+        if result.returncode != 0:
+            log(f"  Warning: install.py failed: {result.stderr.strip()[:200]}")
+
+
+def install_node_dependencies(
+    node_deps: "List[NodeDependency]",
+    custom_nodes_dir: Path,
+    log: Callable[[str], None] = print,
+    visited: Set[str] = None,
+) -> None:
+    """Install node dependencies recursively."""
+    from ..config import discover_config
+
+    visited = visited or set()
+    for dep in node_deps:
+        if dep.name in visited:
+            log(f"  {dep.name}: cycle, skipping")
+            continue
+        visited.add(dep.name)
+
+        node_path = custom_nodes_dir / dep.name
+        if node_path.exists():
+            log(f"  {dep.name}: exists")
+            continue
+
+        try:
+            clone_node(dep.repo, dep.name, custom_nodes_dir, log)
+            install_requirements(node_path, log)
+            run_install_script(node_path, log)
+
+            nested_config = discover_config(node_path)
+            if nested_config and nested_config.node_reqs:
+                install_node_dependencies(nested_config.node_reqs, custom_nodes_dir, log, visited)
+        except Exception as e:
+            log(f"  Warning: {dep.name} failed: {e}")

comfy_env/packages/pixi.py

@@ -0,0 +1,85 @@
+"""Pixi package manager integration. See: https://pixi.sh/"""
+
+import platform as platform_mod
+import shutil
+import stat
+import subprocess
+import sys
+import urllib.request
+from pathlib import Path
+from typing import Callable, List, Optional
+
+PIXI_URLS = {
+    ("Linux", "x86_64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-x86_64-unknown-linux-musl",
+    ("Linux", "aarch64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-aarch64-unknown-linux-musl",
+    ("Darwin", "x86_64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-x86_64-apple-darwin",
+    ("Darwin", "arm64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-aarch64-apple-darwin",
+    ("Windows", "AMD64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-x86_64-pc-windows-msvc.exe",
+}
+
+
+def get_pixi_path() -> Optional[Path]:
+    """Find pixi in PATH or common locations."""
+    if cmd := shutil.which("pixi"): return Path(cmd)
+    home = Path.home()
+    for p in [home / ".pixi/bin/pixi", home / ".local/bin/pixi"]:
+        candidate = p.with_suffix(".exe") if sys.platform == "win32" else p
+        if candidate.exists(): return candidate
+    return None
+
+
+def ensure_pixi(install_dir: Optional[Path] = None, log: Callable[[str], None] = print) -> Path:
+    """Ensure pixi is installed, downloading if necessary."""
+    if existing := get_pixi_path(): return existing
+
+    log("Pixi not found, downloading...")
+    install_dir = install_dir or Path.home() / ".local/bin"
+    install_dir.mkdir(parents=True, exist_ok=True)
+
+    system, machine = platform_mod.system(), platform_mod.machine()
+    if machine in ("x86_64", "AMD64"): machine = "x86_64" if system != "Windows" else "AMD64"
+    elif machine in ("arm64", "aarch64"): machine = "arm64" if system == "Darwin" else "aarch64"
+
+    if (system, machine) not in PIXI_URLS:
+        raise RuntimeError(f"No pixi for {system}/{machine}")
+
+    pixi_path = install_dir / ("pixi.exe" if system == "Windows" else "pixi")
+    try:
+        urllib.request.urlretrieve(PIXI_URLS[(system, machine)], pixi_path)
+    except Exception as e:
+        result = subprocess.run(["curl", "-fsSL", "-o", str(pixi_path), PIXI_URLS[(system, machine)]], capture_output=True, text=True)
+        if result.returncode != 0: raise RuntimeError(f"Failed to download pixi") from e
+
+    if system != "Windows":
+        pixi_path.chmod(pixi_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+    log(f"Installed pixi: {pixi_path}")
+    return pixi_path
+
+
+def get_pixi_python(node_dir: Path) -> Optional[Path]:
+    """Get Python path from pixi environment."""
+    from ..environment.cache import resolve_env_path
+    env_path, _, _ = resolve_env_path(node_dir)
+    if not env_path: return None
+    python_path = env_path / ("python.exe" if sys.platform == "win32" else "bin/python")
+    return python_path if python_path.exists() else None
+
+
+def pixi_install(node_dir: Path, log: Callable[[str], None] = print) -> subprocess.CompletedProcess:
+    pixi_path = get_pixi_path()
+    if not pixi_path: raise RuntimeError("Pixi not found")
+    return subprocess.run([str(pixi_path), "install"], cwd=node_dir, capture_output=True, text=True)
+
+
+def pixi_run(command: List[str], node_dir: Path, log: Callable[[str], None] = print) -> subprocess.CompletedProcess:
+    pixi_path = get_pixi_path()
+    if not pixi_path: raise RuntimeError("Pixi not found")
+    return subprocess.run([str(pixi_path), "run"] + command, cwd=node_dir, capture_output=True, text=True)
+
+
+def pixi_clean(node_dir: Path, log: Callable[[str], None] = print) -> None:
+    """Remove pixi artifacts (pixi.toml, pixi.lock, .pixi/)."""
+    for path in [node_dir / "pixi.toml", node_dir / "pixi.lock"]:
+        if path.exists(): path.unlink()
+    if (node_dir / ".pixi").exists(): shutil.rmtree(node_dir / ".pixi")

comfy_env/packages/toml_generator.py

@@ -0,0 +1,88 @@
+"""Generate pixi.toml from ComfyEnvConfig."""
+
+import copy
+import sys
+from pathlib import Path
+from typing import Any, Callable, Dict
+
+from ..config import ComfyEnvConfig
+from ..detection import get_recommended_cuda_version, get_pixi_platform
+from .cuda_wheels import CUDA_TORCH_MAP
+
+
+def _require_tomli_w():
+    try:
+        import tomli_w
+        return tomli_w
+    except ImportError:
+        raise ImportError("tomli-w required: pip install tomli-w")
+
+
+def generate_pixi_toml(cfg: ComfyEnvConfig, node_dir: Path, log: Callable[[str], None] = print) -> str:
+    return _require_tomli_w().dumps(config_to_pixi_dict(cfg, node_dir, log))
+
+
+def write_pixi_toml(cfg: ComfyEnvConfig, node_dir: Path, log: Callable[[str], None] = print) -> Path:
+    tomli_w = _require_tomli_w()
+    pixi_toml = node_dir / "pixi.toml"
+    with open(pixi_toml, "wb") as f:
+        tomli_w.dump(config_to_pixi_dict(cfg, node_dir, log), f)
+    log(f"Generated {pixi_toml}")
+    return pixi_toml
+
+
+def config_to_pixi_dict(cfg: ComfyEnvConfig, node_dir: Path, log: Callable[[str], None] = print) -> Dict[str, Any]:
+    pixi_data = copy.deepcopy(cfg.pixi_passthrough)
+
+    cuda_version = torch_version = None
+    if cfg.has_cuda and sys.platform != "darwin":
+        cuda_version = get_recommended_cuda_version()
+        if cuda_version:
+            torch_version = CUDA_TORCH_MAP.get(".".join(cuda_version.split(".")[:2]), "2.8")
+            log(f"CUDA {cuda_version} -> PyTorch {torch_version}")
+
+    # Workspace
+    workspace = pixi_data.setdefault("workspace", {})
+    workspace.setdefault("name", node_dir.name)
+    workspace.setdefault("version", "0.1.0")
+    workspace.setdefault("channels", ["conda-forge"])
+    workspace.setdefault("platforms", [get_pixi_platform()])
+
+    # System requirements
+    if sys.platform.startswith("linux") or cuda_version:
+        system_reqs = pixi_data.setdefault("system-requirements", {})
+        if sys.platform.startswith("linux"):
+            system_reqs.setdefault("libc", {"family": "glibc", "version": "2.35"})
+        if cuda_version:
+            system_reqs["cuda"] = cuda_version.split(".")[0]
+
+    # Dependencies
+    dependencies = pixi_data.setdefault("dependencies", {})
+    py_version = cfg.python or f"{sys.version_info.major}.{sys.version_info.minor}"
+    dependencies.setdefault("python", f"{py_version}.*")
+    dependencies.setdefault("pip", "*")
+
+    # PyTorch CUDA index
+    if cfg.has_cuda and cuda_version:
+        pypi_options = pixi_data.setdefault("pypi-options", {})
+        pytorch_index = f"https://download.pytorch.org/whl/cu{cuda_version.replace('.', '')[:3]}"
+        extra_urls = pypi_options.setdefault("extra-index-urls", [])
+        if pytorch_index not in extra_urls: extra_urls.append(pytorch_index)
+
+    # Enforce torch version
+    if cfg.has_cuda and torch_version:
+        pypi_deps = pixi_data.setdefault("pypi-dependencies", {})
+        torch_minor = int(torch_version.split(".")[1])
+        pypi_deps["torch"] = f">={torch_version},<{torch_version.split('.')[0]}.{torch_minor + 1}"
+
+    return pixi_data
+
+
+def deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+    result = copy.deepcopy(base)
+    for k, v in override.items():
+        if k in result and isinstance(result[k], dict) and isinstance(v, dict):
+            result[k] = deep_merge(result[k], v)
+        else:
+            result[k] = copy.deepcopy(v)
+    return result