comfy-env 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

comfy_env/__init__.py

@@ -1,12 +1,4 @@
-"""
-comfy-env: Environment management for ComfyUI custom nodes.
-
-All dependencies go through pixi for unified management.
-
-Main APIs:
-- install(): Install dependencies from comfy-env.toml
-- wrap_isolated_nodes(): Wrap nodes for subprocess isolation
-"""
+"""Environment management for ComfyUI custom nodes."""
 
 from importlib.metadata import version, PackageNotFoundError
 
@@ -48,32 +40,34 @@ from .workers import (
 )
 
 # Isolation
-from .isolation import wrap_isolated_nodes
+from .isolation import wrap_isolated_nodes, wrap_nodes
 
 # Install API
-from .install import install, verify_installation
+from .install import install, verify_installation, USE_COMFY_ENV_VAR
 
 # Prestartup helpers
-from .prestartup import setup_env
+from .prestartup import setup_env, copy_files
 
-# Errors
-from .errors import (
-    EnvManagerError,
-    ConfigError,
-    WheelNotFoundError,
-    DependencyError,
-    CUDANotFoundError,
-    InstallError,
+# Cache management
+from .cache import (
+    get_cache_dir,
+    cleanup_orphaned_envs,
+    resolve_env_path,
+    CACHE_DIR,
+    MARKER_FILE,
 )
 
 __all__ = [
     # Install API
     "install",
     "verify_installation",
+    "USE_COMFY_ENV_VAR",
     # Prestartup
     "setup_env",
+    "copy_files",
     # Isolation
     "wrap_isolated_nodes",
+    "wrap_nodes",
     # Config
     "ComfyEnvConfig",
     "NodeReq",
@@ -98,11 +92,20 @@ __all__ = [
     "WorkerError",
     "MPWorker",
     "SubprocessWorker",
-    # Errors
-    "EnvManagerError",
-    "ConfigError",
-    "WheelNotFoundError",
-    "DependencyError",
-    "CUDANotFoundError",
-    "InstallError",
+    # Cache
+    "get_cache_dir",
+    "cleanup_orphaned_envs",
+    "resolve_env_path",
+    "CACHE_DIR",
+    "MARKER_FILE",
 ]
+
+# Run orphan cleanup once on module load (silently)
+def _run_startup_cleanup():
+    """Clean orphaned envs on startup."""
+    try:
+        cleanup_orphaned_envs(log=lambda x: None)  # Silent
+    except Exception:
+        pass  # Never fail startup due to cleanup
+
+_run_startup_cleanup()

comfy_env/cache.py

@@ -0,0 +1,203 @@
+"""Central environment cache management."""
+
+import hashlib
+import os
+import shutil
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Tuple, Callable
+
+# Import version
+try:
+    from . import __version__
+except ImportError:
+    __version__ = "0.0.0-dev"
+
+import tomli
+import tomli_w
+
+
+# Constants
+CACHE_DIR = Path.home() / ".comfy-env" / "envs"
+MARKER_FILE = ".comfy-env-marker.toml"
+METADATA_FILE = ".comfy-env-metadata.toml"
+
+
+def get_cache_dir() -> Path:
+    """Get central cache directory, create if needed."""
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    return CACHE_DIR
+
+
+def compute_config_hash(config_path: Path) -> str:
+    """Compute hash of comfy-env.toml content (first 8 chars of SHA256)."""
+    content = config_path.read_bytes()
+    return hashlib.sha256(content).hexdigest()[:8]
+
+
+def sanitize_name(name: str) -> str:
+    """Sanitize a name for use in filesystem paths."""
+    # Lowercase and replace problematic chars
+    name = name.lower()
+    for prefix in ("comfyui-", "comfyui_"):
+        if name.startswith(prefix):
+            name = name[len(prefix):]
+    return name.replace("-", "_").replace(" ", "_")
+
+
+def get_env_name(node_dir: Path, config_path: Path) -> str:
+    """Generate env name: <nodename>_<subfolder>_<hash>."""
+    # Get node name
+    node_name = sanitize_name(node_dir.name)
+
+    # Get subfolder (relative path from node_dir to config parent)
+    config_parent = config_path.parent
+    if config_parent == node_dir:
+        subfolder = ""
+    else:
+        try:
+            rel_path = config_parent.relative_to(node_dir)
+            subfolder = rel_path.as_posix().replace("/", "_")
+        except ValueError:
+            # config_path not under node_dir - use parent folder name
+            subfolder = sanitize_name(config_parent.name)
+
+    # Compute hash
+    config_hash = compute_config_hash(config_path)
+
+    return f"{node_name}_{subfolder}_{config_hash}"
+
+
+def get_central_env_path(node_dir: Path, config_path: Path) -> Path:
+    """Get path to central environment for this config."""
+    env_name = get_env_name(node_dir, config_path)
+    return get_cache_dir() / env_name
+
+
+def write_marker(config_path: Path, env_path: Path) -> None:
+    """Write marker file linking node to central env."""
+    marker_path = config_path.parent / MARKER_FILE
+    marker_data = {
+        "env": {
+            "name": env_path.name,
+            "path": str(env_path),
+            "config_hash": compute_config_hash(config_path),
+            "created": datetime.now().isoformat(),
+            "comfy_env_version": __version__,
+        }
+    }
+    marker_path.write_text(tomli_w.dumps(marker_data))
+
+
+def write_env_metadata(env_path: Path, marker_path: Path) -> None:
+    """Write metadata file for orphan detection."""
+    metadata_path = env_path / METADATA_FILE
+    metadata = {
+        "marker_path": str(marker_path),
+        "created": datetime.now().isoformat(),
+    }
+    metadata_path.write_text(tomli_w.dumps(metadata))
+
+
+def read_marker(marker_path: Path) -> Optional[dict]:
+    """Read marker file, return None if invalid/missing."""
+    if not marker_path.exists():
+        return None
+    try:
+        with open(marker_path, "rb") as f:
+            return tomli.load(f)
+    except Exception:
+        return None
+
+
+def read_env_metadata(env_path: Path) -> Optional[dict]:
+    """Read metadata file from env, return None if invalid/missing."""
+    metadata_path = env_path / METADATA_FILE
+    if not metadata_path.exists():
+        return None
+    try:
+        with open(metadata_path, "rb") as f:
+            return tomli.load(f)
+    except Exception:
+        return None
+
+
+def resolve_env_path(node_dir: Path) -> Tuple[Optional[Path], Optional[Path], Optional[Path]]:
+    """Resolve environment path. Returns (env_path, site_packages, lib_dir)."""
+    # 1. Check marker file -> central cache
+    marker_path = node_dir / MARKER_FILE
+    marker = read_marker(marker_path)
+    if marker and "env" in marker:
+        env_path = Path(marker["env"]["path"])
+        if env_path.exists():
+            return _get_env_paths(env_path)
+
+    # 2. Check _env_<name>
+    node_name = sanitize_name(node_dir.name)
+    env_name = f"_env_{node_name}"
+    local_env = node_dir / env_name
+    if local_env.exists():
+        return _get_env_paths(local_env)
+
+    # 3. Check .pixi/envs/default
+    pixi_env = node_dir / ".pixi" / "envs" / "default"
+    if pixi_env.exists():
+        return _get_env_paths(pixi_env)
+
+    # 4. Check .venv
+    venv_dir = node_dir / ".venv"
+    if venv_dir.exists():
+        return _get_env_paths(venv_dir)
+
+    return None, None, None
+
+
+def _get_env_paths(env_path: Path) -> Tuple[Path, Optional[Path], Optional[Path]]:
+    """Get site-packages and lib paths from an environment."""
+    import glob
+
+    if sys.platform == "win32":
+        site_packages = env_path / "Lib" / "site-packages"
+        lib_dir = env_path / "Library" / "bin"
+    else:
+        # Linux/Mac: lib/python*/site-packages
+        matches = glob.glob(str(env_path / "lib" / "python*" / "site-packages"))
+        site_packages = Path(matches[0]) if matches else None
+        lib_dir = env_path / "lib"
+
+    return env_path, site_packages, lib_dir
+
+
+def cleanup_orphaned_envs(log: Callable[[str], None] = print) -> int:
+    """Remove orphaned environments. Returns count cleaned."""
+    cache_dir = get_cache_dir()
+    if not cache_dir.exists():
+        return 0
+
+    cleaned = 0
+    for env_dir in cache_dir.iterdir():
+        if not env_dir.is_dir():
+            continue
+
+        # Skip if no metadata (might be manually created or old format)
+        metadata = read_env_metadata(env_dir)
+        if not metadata:
+            continue
+
+        # Check if marker file still exists
+        marker_path_str = metadata.get("marker_path", "")
+        if not marker_path_str:
+            continue
+
+        marker_path = Path(marker_path_str)
+        if not marker_path.exists():
+            # Marker gone = node was deleted = orphan
+            log(f"[comfy-env] Cleaning orphaned env: {env_dir.name}")
+            try:
+                shutil.rmtree(env_dir)
+                cleaned += 1
+            except Exception as e:
+                log(f"[comfy-env] Failed to cleanup {env_dir.name}: {e}")
+
+    return cleaned

comfy_env/cli.py

@@ -309,7 +309,7 @@ def cmd_info(args) -> int:
 def cmd_doctor(args) -> int:
     """Handle doctor command."""
     from .install import verify_installation
-    from .config.parser import discover_env_config, load_env_from_file
+    from .config.parser import load_config, discover_config
 
     print("Running diagnostics...")
     print("=" * 40)
@@ -325,21 +325,19 @@ def cmd_doctor(args) -> int:
     if args.package:
         packages = [args.package]
     elif args.config:
-        config = load_env_from_file(Path(args.config))
+        config = load_config(Path(args.config))
         if config:
-            packages = (config.requirements or []) + (config.no_deps_requirements or [])
+            # Get packages from pypi-dependencies
+            pypi_deps = config.pixi_passthrough.get("pypi-dependencies", {})
+            packages = list(pypi_deps.keys()) + config.cuda_packages
     else:
-        config = discover_env_config(Path.cwd())
+        config = discover_config(Path.cwd())
         if config:
-            packages = (config.requirements or []) + (config.no_deps_requirements or [])
+            pypi_deps = config.pixi_passthrough.get("pypi-dependencies", {})
+            packages = list(pypi_deps.keys()) + config.cuda_packages
 
     if packages:
-        pkg_names = []
-        for pkg in packages:
-            name = pkg.split("==")[0].split(">=")[0].split("[")[0]
-            pkg_names.append(name)
-
-        all_ok = verify_installation(pkg_names)
+        all_ok = verify_installation(packages)
         if all_ok:
             print("\nAll packages verified!")
             return 0

comfy_env/config/__init__.py

@@ -1,18 +1,16 @@
-"""
-Config parsing for comfy-env.
+"""Config parsing for comfy-env."""
 
-This module handles parsing comfy-env.toml files and provides
-typed configuration objects.
-"""
-
-from .types import ComfyEnvConfig, NodeReq
-from .parser import load_config, discover_config, CONFIG_FILE_NAME
+from .parser import (
+    ComfyEnvConfig,
+    NodeReq,
+    load_config,
+    discover_config,
+    CONFIG_FILE_NAME,
+)
 
 __all__ = [
-    # Types
     "ComfyEnvConfig",
     "NodeReq",
-    # Parser
     "load_config",
     "discover_config",
     "CONFIG_FILE_NAME",

comfy_env/config/parser.py

@@ -1,100 +1,53 @@
-"""Load configuration from comfy-env.toml.
-
-comfy-env.toml is a superset of pixi.toml. Custom sections we handle:
-- python = "3.11" - Python version for isolated envs
-- [cuda] packages = [...] - CUDA packages (triggers find-links + PyTorch detection)
-- [node_reqs] - Other ComfyUI nodes to clone
-
-Everything else passes through to pixi.toml directly.
-
-Example config:
-
-    python = "3.11"
-
-    [cuda]
-    packages = ["cumesh"]
-
-    [dependencies]
-    mesalib = "*"
-    cgal = "*"
-
-    [pypi-dependencies]
-    numpy = ">=1.21.0,<2"
-    trimesh = { version = ">=4.0.0", extras = ["easy"] }
-
-    [target.linux-64.pypi-dependencies]
-    embreex = "*"
+"""
+Configuration parsing for comfy-env.
 
-    [node_reqs]
-    SomeNode = "owner/repo"
+Loads comfy-env.toml (a superset of pixi.toml) and provides typed config objects.
 """
 
 import copy
 import sys
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Optional, Dict, Any, List
+import tomli
 
-# Use built-in tomllib (Python 3.11+) or tomli fallback
-if sys.version_info >= (3, 11):
-    import tomllib
-else:
-    try:
-        import tomli as tomllib
-    except ImportError:
-        tomllib = None  # type: ignore
-
-from .types import ComfyEnvConfig, NodeReq
-
-
+# --- Types&Constants ---
 CONFIG_FILE_NAME = "comfy-env.toml"
 
-# Sections we handle specially (not passed through to pixi.toml)
-CUSTOM_SECTIONS = {"python", "cuda", "node_reqs", "apt", "env_vars"}
-
+@dataclass
+class NodeReq:
+    """A node dependency (another ComfyUI custom node)."""
+    name: str
+    repo: str  # GitHub repo, e.g., "owner/repo"
 
-def load_config(path: Path) -> ComfyEnvConfig:
-    """
-    Load configuration from a TOML file.
+@dataclass
+class ComfyEnvConfig:
+    """Configuration from comfy-env.toml."""
+    python: Optional[str] = None
+    cuda_packages: List[str] = field(default_factory=list)
+    apt_packages: List[str] = field(default_factory=list)
+    env_vars: Dict[str, str] = field(default_factory=dict)
+    node_reqs: List[NodeReq] = field(default_factory=list)
+    pixi_passthrough: Dict[str, Any] = field(default_factory=dict)
 
-    Args:
-        path: Path to comfy-env.toml
+    @property
+    def has_cuda(self) -> bool:
+        return bool(self.cuda_packages)
+# --- Types&Constants ---
 
-    Returns:
-        ComfyEnvConfig instance
-
-    Raises:
-        FileNotFoundError: If config file doesn't exist
-        ImportError: If tomli not installed (Python < 3.11)
-    """
-    if tomllib is None:
-        raise ImportError(
-            "TOML parsing requires tomli for Python < 3.11. "
-            "Install with: pip install tomli"
-        )
 
+def load_config(path: Path) -> ComfyEnvConfig:
+    """Load config from a TOML file."""
     path = Path(path)
     if not path.exists():
         raise FileNotFoundError(f"Config file not found: {path}")
-
     with open(path, "rb") as f:
-        data = tomllib.load(f)
-
+        data = tomli.load(f)
     return _parse_config(data)
 
 
 def discover_config(node_dir: Path) -> Optional[ComfyEnvConfig]:
-    """
-    Find and load comfy-env.toml from a directory.
-
-    Args:
-        node_dir: Directory to search
-
-    Returns:
-        ComfyEnvConfig if found, None otherwise
-    """
-    if tomllib is None:
-        return None
-
+    """Find and load comfy-env.toml from a directory."""
     config_path = Path(node_dir) / CONFIG_FILE_NAME
     if config_path.exists():
         return load_config(config_path)

comfy_env/install.py

@@ -1,17 +1,21 @@
-"""
-Installation API for comfy-env.
-
-Example:
-    from comfy_env import install
-    install()  # Auto-discovers comfy-env.toml and installs
-"""
+"""Installation API for comfy-env."""
 
 import inspect
+import os
 from pathlib import Path
 from typing import Callable, List, Optional, Set, Union
 
-from .config.types import ComfyEnvConfig, NodeReq
-from .config.parser import load_config, discover_config
+from .config.parser import ComfyEnvConfig, NodeReq, load_config, discover_config
+
+
+# Environment variable to disable comfy-env isolation
+USE_COMFY_ENV_VAR = "USE_COMFY_ENV"
+
+
+def _is_comfy_env_enabled() -> bool:
+    """Check if isolation is enabled."""
+    val = os.environ.get(USE_COMFY_ENV_VAR, "1").lower()
+    return val not in ("0", "false", "no", "off")
 
 
 def install(
@@ -20,18 +24,7 @@ def install(
     log_callback: Optional[Callable[[str], None]] = None,
     dry_run: bool = False,
 ) -> bool:
-    """
-    Install dependencies from comfy-env.toml.
-
-    Args:
-        config: Optional path to comfy-env.toml. Auto-discovered if not provided.
-        node_dir: Optional node directory. Auto-discovered from caller if not provided.
-        log_callback: Optional callback for logging. Defaults to print.
-        dry_run: If True, show what would be installed without installing.
-
-    Returns:
-        True if installation succeeded.
-    """
+    """Install dependencies from comfy-env.toml."""
     # Auto-discover caller's directory if not provided
     if node_dir is None:
         frame = inspect.stack()[1]
@@ -67,11 +60,17 @@ def install(
     if cfg.node_reqs:
         _install_node_dependencies(cfg.node_reqs, node_dir, log, dry_run)
 
-    # Install everything via pixi
-    _install_via_pixi(cfg, node_dir, log, dry_run)
+    # Check if isolation is enabled
+    if _is_comfy_env_enabled():
+        # Install everything via pixi (isolated environment)
+        _install_via_pixi(cfg, node_dir, log, dry_run)
 
-    # Auto-discover and install isolated subdirectory environments
-    _install_isolated_subdirs(node_dir, log, dry_run)
+        # Auto-discover and install isolated subdirectory environments
+        _install_isolated_subdirs(node_dir, log, dry_run)
+    else:
+        # Install directly to host Python (no isolation)
+        log("\n[comfy-env] Isolation disabled (USE_COMFY_ENV=0)")
+        _install_to_host_python(cfg, node_dir, log, dry_run)
 
     log("\nInstallation complete!")
     return True
@@ -291,6 +290,123 @@ def _install_via_pixi(
     pixi_install(cfg, node_dir, log)
 
 
+def _install_to_host_python(
+    cfg: ComfyEnvConfig,
+    node_dir: Path,
+    log: Callable[[str], None],
+    dry_run: bool,
+) -> None:
+    """Install packages directly to host Python (no isolation)."""
+    import shutil
+    import subprocess
+    import sys
+
+    from .pixi import CUDA_WHEELS_INDEX, find_wheel_url
+    from .pixi.cuda_detection import get_recommended_cuda_version
+
+    # Collect packages to install
+    pypi_deps = cfg.pixi_passthrough.get("pypi-dependencies", {})
+    conda_deps = cfg.pixi_passthrough.get("dependencies", {})
+
+    # Warn about conda dependencies (can't install without pixi)
+    # Filter out 'python' and 'pip' which are meta-dependencies
+    real_conda_deps = {k: v for k, v in conda_deps.items() if k not in ("python", "pip")}
+    if real_conda_deps:
+        log(f"\n[warning] Cannot install conda packages without isolation:")
+        for pkg in real_conda_deps:
+            log(f"  - {pkg}")
+        log("  Set USE_COMFY_ENV=1 to enable isolated environments")
+
+    # Nothing to install?
+    if not pypi_deps and not cfg.cuda_packages:
+        log("No packages to install")
+        return
+
+    # Build pip install command
+    pip_packages = []
+
+    # Add pypi dependencies
+    for pkg, spec in pypi_deps.items():
+        if isinstance(spec, str):
+            if spec == "*":
+                pip_packages.append(pkg)
+            else:
+                pip_packages.append(f"{pkg}{spec}")
+        elif isinstance(spec, dict):
+            version = spec.get("version", "*")
+            extras = spec.get("extras", [])
+            if extras:
+                pkg_with_extras = f"{pkg}[{','.join(extras)}]"
+            else:
+                pkg_with_extras = pkg
+            if version == "*":
+                pip_packages.append(pkg_with_extras)
+            else:
+                pip_packages.append(f"{pkg_with_extras}{version}")
+
+    log(f"\nInstalling to host Python ({sys.executable}):")
+    if pip_packages:
+        log(f"  PyPI packages: {len(pip_packages)}")
+    if cfg.cuda_packages:
+        log(f"  CUDA packages: {', '.join(cfg.cuda_packages)}")
+
+    if dry_run:
+        if pip_packages:
+            log(f"  Would install: {', '.join(pip_packages)}")
+        log("\n(dry run - no changes made)")
+        return
+
+    # Use uv if available, otherwise pip
+    use_uv = shutil.which("uv") is not None
+
+    # Install regular PyPI packages
+    if pip_packages:
+        if use_uv:
+            cmd = ["uv", "pip", "install", "--python", sys.executable] + pip_packages
+        else:
+            cmd = [sys.executable, "-m", "pip", "install"] + pip_packages
+
+        log(f"  Running: {' '.join(cmd[:4])}...")
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            log(f"  [error] pip install failed: {result.stderr.strip()[:200]}")
+        else:
+            log(f"  Installed {len(pip_packages)} package(s)")
+
+    # Install CUDA packages from cuda-wheels
+    if cfg.cuda_packages:
+        cuda_version = get_recommended_cuda_version()
+        if not cuda_version:
+            log("  [warning] No CUDA detected, skipping CUDA packages")
+            return
+
+        # Get torch version for wheel matching
+        cuda_mm = ".".join(cuda_version.split(".")[:2])
+        from .pixi.core import CUDA_TORCH_MAP
+        torch_version = CUDA_TORCH_MAP.get(cuda_mm, "2.8")
+
+        py_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+        log(f"  CUDA {cuda_version}, PyTorch {torch_version}, Python {py_version}")
+
+        for package in cfg.cuda_packages:
+            wheel_url = find_wheel_url(package, torch_version, cuda_version, py_version)
+            if not wheel_url:
+                log(f"  [error] No wheel found for {package}")
+                continue
+
+            log(f"  Installing {package}...")
+            if use_uv:
+                cmd = ["uv", "pip", "install", "--python", sys.executable, "--no-deps", wheel_url]
+            else:
+                cmd = [sys.executable, "-m", "pip", "install", "--no-deps", wheel_url]
+
+            result = subprocess.run(cmd, capture_output=True, text=True)
+            if result.returncode != 0:
+                log(f"  [error] Failed to install {package}: {result.stderr.strip()[:200]}")
+            else:
+                log(f"  Installed {package}")
+
+
 def _install_isolated_subdirs(
     node_dir: Path,
     log: Callable[[str], None],

comfy_env/isolation/__init__.py

@@ -2,8 +2,9 @@
 Isolation module for wrapping ComfyUI nodes to run in isolated environments.
 """
 
-from .wrap import wrap_isolated_nodes
+from .wrap import wrap_isolated_nodes, wrap_nodes
 
 __all__ = [
     "wrap_isolated_nodes",
+    "wrap_nodes",
 ]