comfy-env 0.0.24__tar.gz → 0.0.25__tar.gz

{comfy_env-0.0.24 → comfy_env-0.0.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.24
+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.24 → comfy_env-0.0.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfy-env"
-version = "0.0.24"
+version = "0.0.25"
 description = "Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation"
 readme = "README.md"
 license = {text = "MIT"}

{comfy_env-0.0.24 → comfy_env-0.0.25}/src/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-0.0.25/src/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}")