comfy-env 0.0.23__py3-none-any.whl → 0.0.25__py3-none-any.whl

comfy_env/install.py

@@ -22,9 +22,9 @@ import shutil
 import subprocess
 import sys
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Set, Union
 
-from .env.config import IsolatedEnv, SystemConfig
+from .env.config import IsolatedEnv, NodeReq, SystemConfig
 from .env.config_file import load_config, discover_config
 from .env.manager import IsolatedEnvManager
 from .errors import CUDANotFoundError, DependencyError, InstallError, WheelNotFoundError
@@ -132,6 +132,47 @@ def _install_system_packages(
     return True
 
 
+def _install_node_dependencies(
+    node_reqs: List[NodeReq],
+    node_dir: Path,
+    log: Callable[[str], None],
+    dry_run: bool = False,
+) -> bool:
+    """
+    Install node dependencies (other ComfyUI custom nodes).
+
+    Args:
+        node_reqs: List of NodeReq objects from [node_reqs] config section.
+        node_dir: Directory of the current node (used to find custom_nodes/).
+        log: Logging callback.
+        dry_run: If True, show what would be installed without installing.
+
+    Returns:
+        True if installation succeeded or no dependencies needed.
+    """
+    from .nodes import install_node_deps
+
+    # Detect custom_nodes directory (parent of current node)
+    custom_nodes_dir = node_dir.parent
+
+    log(f"\nInstalling {len(node_reqs)} node dependencies...")
+
+    if dry_run:
+        for req in node_reqs:
+            node_path = custom_nodes_dir / req.name
+            status = "exists" if node_path.exists() else "would clone"
+            log(f"  {req.name}: {status}")
+        return True
+
+    # Track visited nodes to prevent cycles
+    # Start with current node's directory name
+    visited: Set[str] = {node_dir.name}
+
+    install_node_deps(node_reqs, custom_nodes_dir, log, visited)
+
+    return True
+
+
 def install(
     config: Optional[Union[str, Path]] = None,
     mode: str = "inplace",
@@ -185,7 +226,12 @@ def install(
             "Create comfy-env.toml or specify path explicitly."
         )
 
-    # Install system packages first (apt, brew, etc.)
+    # Install node dependencies first (other ComfyUI custom nodes)
+    # These may have their own system packages and Python packages
+    if full_config.node_reqs:
+        _install_node_dependencies(full_config.node_reqs, node_dir, log, dry_run)
+
+    # Install system packages (apt, brew, etc.)
     # These need to be installed before Python packages that depend on them
     if full_config.has_system:
         _install_system_packages(full_config.system, log, dry_run)

comfy_env/nodes.py

@@ -0,0 +1,154 @@
+"""
+Node dependency installation for comfy-env.
+
+This module handles installation of dependent ComfyUI custom nodes
+specified in the [node_reqs] section of comfy-env.toml.
+
+Example configuration:
+    [node_reqs]
+    ComfyUI_essentials = "cubiq/ComfyUI_essentials"
+    ComfyUI-DepthAnythingV2 = "kijai/ComfyUI-DepthAnythingV2"
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, Callable, List, Set
+
+if TYPE_CHECKING:
+    from .env.config import NodeReq
+
+
+def normalize_repo_url(repo: str) -> str:
+    """
+    Convert GitHub shorthand to full URL.
+
+    Args:
+        repo: Either 'owner/repo' or full URL like 'https://github.com/owner/repo'
+
+    Returns:
+        Full GitHub URL
+    """
+    if repo.startswith("http://") or repo.startswith("https://"):
+        return repo
+    return f"https://github.com/{repo}"
+
+
+def clone_node(
+    repo: str,
+    name: str,
+    target_dir: Path,
+    log: Callable[[str], None],
+) -> Path:
+    """
+    Clone a node repository to target_dir/name.
+
+    Args:
+        repo: GitHub repo path (e.g., 'owner/repo') or full URL
+        name: Directory name for the cloned repo
+        target_dir: Parent directory (usually custom_nodes/)
+        log: Logging callback
+
+    Returns:
+        Path to the cloned node directory
+
+    Raises:
+        RuntimeError: If git clone fails
+    """
+    node_path = target_dir / name
+    url = normalize_repo_url(repo)
+
+    log(f"  Cloning {name} from {url}...")
+    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 run_install_script(
+    node_dir: Path,
+    log: Callable[[str], None],
+) -> None:
+    """
+    Run install.py in a node directory if it exists.
+
+    Args:
+        node_dir: Path to the node directory
+        log: Logging callback
+    """
+    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 for {node_dir.name}: {result.stderr.strip()[:200]}")
+
+
+def install_node_deps(
+    node_reqs: "List[NodeReq]",
+    custom_nodes_dir: Path,
+    log: Callable[[str], None],
+    visited: Set[str],
+) -> None:
+    """
+    Install node dependencies recursively.
+
+    Args:
+        node_reqs: List of NodeReq objects to install
+        custom_nodes_dir: Path to custom_nodes directory
+        log: Logging callback
+        visited: Set of already-processed node names (for cycle detection)
+    """
+    from .env.config_file import discover_config
+
+    for req in node_reqs:
+        # Skip if already visited (cycle detection)
+        if req.name in visited:
+            log(f"  {req.name}: already in dependency chain, skipping")
+            continue
+
+        visited.add(req.name)
+
+        node_path = custom_nodes_dir / req.name
+
+        # Skip if already installed (directory exists)
+        if node_path.exists():
+            log(f"  {req.name}: already installed, skipping")
+            continue
+
+        try:
+            # Clone the repository
+            clone_node(req.repo, req.name, custom_nodes_dir, log)
+
+            # Run install.py if present
+            run_install_script(node_path, log)
+
+            # Recursively process nested node_reqs
+            try:
+                nested_config = discover_config(node_path)
+                if nested_config and nested_config.node_reqs:
+                    log(f"  {req.name}: found {len(nested_config.node_reqs)} nested dependencies")
+                    install_node_deps(
+                        nested_config.node_reqs,
+                        custom_nodes_dir,
+                        log,
+                        visited,
+                    )
+            except Exception as e:
+                # Don't fail if we can't parse nested config
+                log(f"  {req.name}: could not check for nested deps: {e}")
+
+        except Exception as e:
+            log(f"  Warning: Failed to install {req.name}: {e}")

comfy_env/pixi.py

@@ -274,6 +274,35 @@ def create_pixi_toml(
     return pixi_toml_path
 
 
+def clean_pixi_artifacts(
+    node_dir: Path,
+    log: Callable[[str], None] = print,
+) -> None:
+    """
+    Remove previous pixi installation artifacts.
+
+    This ensures a clean state before generating a new pixi.toml,
+    preventing stale lock files or cached environments from causing conflicts.
+
+    Args:
+        node_dir: Directory containing the pixi artifacts.
+        log: Logging callback.
+    """
+    pixi_toml = node_dir / "pixi.toml"
+    pixi_lock = node_dir / "pixi.lock"
+    pixi_dir = node_dir / ".pixi"
+
+    if pixi_toml.exists():
+        pixi_toml.unlink()
+        log("  Removed previous pixi.toml")
+    if pixi_lock.exists():
+        pixi_lock.unlink()
+        log("  Removed previous pixi.lock")
+    if pixi_dir.exists():
+        shutil.rmtree(pixi_dir)
+        log("  Removed previous .pixi/ directory")
+
+
 def pixi_install(
     env_config: IsolatedEnv,
     node_dir: Path,
@@ -284,9 +313,10 @@ def pixi_install(
     Install conda and pip packages using pixi.
 
     This is the main entry point for pixi-based installation. It:
-    1. Ensures pixi is installed
-    2. Generates pixi.toml from the config
-    3. Runs `pixi install` to install all dependencies
+    1. Cleans previous pixi artifacts
+    2. Ensures pixi is installed
+    3. Generates pixi.toml from the config
+    4. Runs `pixi install` to install all dependencies
 
     Args:
         env_config: The isolated environment configuration.
@@ -304,6 +334,7 @@ def pixi_install(
 
     if dry_run:
         log("Dry run - would:")
+        log(f"  - Clean previous pixi artifacts")
         log(f"  - Ensure pixi is installed")
         log(f"  - Generate pixi.toml in {node_dir}")
         if env_config.conda:
@@ -312,6 +343,9 @@ def pixi_install(
             log(f"  - Install {len(env_config.requirements)} pip packages")
         return True
 
+    # Clean previous pixi artifacts
+    clean_pixi_artifacts(node_dir, log)
+
     # Ensure pixi is installed
     pixi_path = ensure_pixi(log=log)
 

{comfy_env-0.0.23.dist-info → comfy_env-0.0.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.23
+Version: 0.0.25
 Summary: Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation
 Project-URL: Homepage, https://github.com/PozzettiAndrea/comfy-env
 Project-URL: Repository, https://github.com/PozzettiAndrea/comfy-env

{comfy_env-0.0.23.dist-info → comfy_env-0.0.25.dist-info}/RECORD

@@ -2,8 +2,9 @@ comfy_env/__init__.py,sha256=u2uTyoysPQyNMcRp5U4VTMJF11FBW6Goqu0DN-BdUuY,3678
 comfy_env/cli.py,sha256=X-GCQMP0mtMcE3ZgkT-VLQ4Gq3UUvcb_Ux_NClEFhgI,15975
 comfy_env/decorator.py,sha256=6JCKwLHaZtOLVDexs_gh_-NtS2ZK0V7nGCPqkyeYEAA,16688
 comfy_env/errors.py,sha256=8hN8NDlo8oBUdapc-eT3ZluigI5VBzfqsSBvQdfWlz4,9943
-comfy_env/install.py,sha256=CA5O0-ghkTdV67fVyKJy6wt1vL35inBeqWtA52udjHI,24301
-comfy_env/pixi.py,sha256=VqAv_sSdCBGIbLS5jLYnxV6rgiunsCUC5NtmpfV7rI4,12296
+comfy_env/install.py,sha256=pyyaYbCFZn6T5_sgjumd1TeFaTEXUTcdFbex31m_JEc,25837
+comfy_env/nodes.py,sha256=CWUe35jU5SKk4ur-SddZePdqWgxJDlxGhpcJiu5pAK4,4354
+comfy_env/pixi.py,sha256=Oj9Z9bBg8IpsPF3usAx9v4w6OhpNk4LQjUuAP5ohnQY,13324
 comfy_env/registry.py,sha256=uFCtGmWYvwGCqObXgzmArX7o5JsFNsHXxayofk3m6no,2569
 comfy_env/resolver.py,sha256=l-AnmCE1puG6CvdpDB-KrsfG_cn_3uO2DryYizUnG_4,12474
 comfy_env/env/__init__.py,sha256=imQdoQEQvrRT-QDtyNpFlkVbm2fBzgACdpQwRPd09fI,1157
@@ -33,8 +34,8 @@ comfy_env/workers/tensor_utils.py,sha256=TCuOAjJymrSbkgfyvcKtQ_KbVWTqSwP9VH_bCaF
 comfy_env/workers/torch_mp.py,sha256=4YSNPn7hALrvMVbkO4RkTeFTcc0lhfLMk5QTWjY4PHw,22134
 comfy_env/workers/venv.py,sha256=_ekHfZPqBIPY08DjqiXm6cTBQH4DrbxRWR3AAv3mit8,31589
 comfy_env/wheel_sources.yml,sha256=nSZ8XB_I5JXQGB7AgC6lHs_IXMd9Kcno10artNL8BKw,7775
-comfy_env-0.0.23.dist-info/METADATA,sha256=oTiCkl-rEq5VD2B9BhRvcCRo9iZyFF5QWLjuYQI3tDI,5400
-comfy_env-0.0.23.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.0.23.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.0.23.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.0.23.dist-info/RECORD,,
+comfy_env-0.0.25.dist-info/METADATA,sha256=IcYAcYC42bhuCU4ijkeY1CfUwX4b3AVRhnFZ3mR1BXw,5400
+comfy_env-0.0.25.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.0.25.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.0.25.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.0.25.dist-info/RECORD,,