comfy-env 0.1.14__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,13 +40,13 @@ 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
 
 # Cache management
 from .cache import (
@@ -65,24 +57,17 @@ from .cache import (
     MARKER_FILE,
 )
 
-# Errors
-from .errors import (
-    EnvManagerError,
-    ConfigError,
-    WheelNotFoundError,
-    DependencyError,
-    CUDANotFoundError,
-    InstallError,
-)
-
 __all__ = [
     # Install API
     "install",
     "verify_installation",
+    "USE_COMFY_ENV_VAR",
     # Prestartup
     "setup_env",
+    "copy_files",
     # Isolation
     "wrap_isolated_nodes",
+    "wrap_nodes",
     # Config
     "ComfyEnvConfig",
     "NodeReq",
@@ -107,13 +92,6 @@ __all__ = [
     "WorkerError",
     "MPWorker",
     "SubprocessWorker",
-    # Errors
-    "EnvManagerError",
-    "ConfigError",
-    "WheelNotFoundError",
-    "DependencyError",
-    "CUDANotFoundError",
-    "InstallError",
     # Cache
     "get_cache_dir",
     "cleanup_orphaned_envs",
@@ -124,7 +102,7 @@ __all__ = [
 
 # Run orphan cleanup once on module load (silently)
 def _run_startup_cleanup():
-    """Clean orphaned envs on startup. Runs silently, never fails startup."""
+    """Clean orphaned envs on startup."""
     try:
         cleanup_orphaned_envs(log=lambda x: None)  # Silent
     except Exception:

comfy_env/cache.py

@@ -1,11 +1,4 @@
-"""
-Central environment cache management for comfy-env.
-
-Stores environments in ~/.comfy-env/envs/<nodename>_<subfolder>_<hash>/
-to avoid Windows MAX_PATH (260 char) issues.
-
-Marker files in node folders link to central envs and enable orphan cleanup.
-"""
+"""Central environment cache management."""
 
 import hashlib
 import os
@@ -21,24 +14,8 @@ try:
 except ImportError:
     __version__ = "0.0.0-dev"
 
-# Lazy import tomli/tomllib
-def _get_tomli():
-    if sys.version_info >= (3, 11):
-        import tomllib
-        return tomllib
-    else:
-        try:
-            import tomli
-            return tomli
-        except ImportError:
-            return None
-
-def _get_tomli_w():
-    try:
-        import tomli_w
-        return tomli_w
-    except ImportError:
-        return None
+import tomli
+import tomli_w
 
 
 # Constants
@@ -70,17 +47,7 @@ def sanitize_name(name: str) -> str:
 
 
 def get_env_name(node_dir: Path, config_path: Path) -> str:
-    """
-    Generate env name: <nodename>_<subfolder>_<hash>
-
-    Args:
-        node_dir: The custom node directory (e.g., custom_nodes/ComfyUI-UniRig)
-        config_path: Path to comfy-env.toml
-
-    Examples:
-        - ComfyUI-UniRig/nodes/comfy-env.toml -> unirig_nodes_a1b2c3d4
-        - ComfyUI-Pack/comfy-env.toml -> pack__f5e6d7c8 (double underscore = no subfolder)
-    """
+    """Generate env name: <nodename>_<subfolder>_<hash>."""
     # Get node name
     node_name = sanitize_name(node_dir.name)
 
@@ -109,27 +76,7 @@ def get_central_env_path(node_dir: Path, config_path: Path) -> Path:
 
 
 def write_marker(config_path: Path, env_path: Path) -> None:
-    """
-    Write marker file linking node to central env.
-
-    Args:
-        config_path: Path to comfy-env.toml
-        env_path: Path to central environment
-    """
-    tomli_w = _get_tomli_w()
-    if not tomli_w:
-        # Fallback to manual TOML writing
-        marker_path = config_path.parent / MARKER_FILE
-        content = f'''[env]
-name = "{env_path.name}"
-path = "{env_path}"
-config_hash = "{compute_config_hash(config_path)}"
-created = "{datetime.now().isoformat()}"
-comfy_env_version = "{__version__}"
-'''
-        marker_path.write_text(content)
-        return
-
+    """Write marker file linking node to central env."""
     marker_path = config_path.parent / MARKER_FILE
     marker_data = {
         "env": {
@@ -144,24 +91,8 @@ comfy_env_version = "{__version__}"
 
 
 def write_env_metadata(env_path: Path, marker_path: Path) -> None:
-    """
-    Write metadata file in env for orphan detection.
-
-    Args:
-        env_path: Path to central environment
-        marker_path: Path to marker file in node folder
-    """
-    tomli_w = _get_tomli_w()
+    """Write metadata file for orphan detection."""
     metadata_path = env_path / METADATA_FILE
-
-    if not tomli_w:
-        # Fallback to manual TOML writing
-        content = f'''marker_path = "{marker_path}"
-created = "{datetime.now().isoformat()}"
-'''
-        metadata_path.write_text(content)
-        return
-
     metadata = {
         "marker_path": str(marker_path),
         "created": datetime.now().isoformat(),
@@ -170,22 +101,9 @@ created = "{datetime.now().isoformat()}"
 
 
 def read_marker(marker_path: Path) -> Optional[dict]:
-    """
-    Read marker file, return None if invalid/missing.
-
-    Args:
-        marker_path: Path to .comfy-env-marker.toml
-
-    Returns:
-        Parsed marker data or None
-    """
+    """Read marker file, return None if invalid/missing."""
     if not marker_path.exists():
         return None
-
-    tomli = _get_tomli()
-    if not tomli:
-        return None
-
     try:
         with open(marker_path, "rb") as f:
             return tomli.load(f)
@@ -194,23 +112,10 @@ def read_marker(marker_path: Path) -> Optional[dict]:
 
 
 def read_env_metadata(env_path: Path) -> Optional[dict]:
-    """
-    Read metadata file from env, return None if invalid/missing.
-
-    Args:
-        env_path: Path to central environment
-
-    Returns:
-        Parsed metadata or None
-    """
+    """Read metadata file from env, return None if invalid/missing."""
     metadata_path = env_path / METADATA_FILE
     if not metadata_path.exists():
         return None
-
-    tomli = _get_tomli()
-    if not tomli:
-        return None
-
     try:
         with open(metadata_path, "rb") as f:
             return tomli.load(f)
@@ -219,21 +124,7 @@ def read_env_metadata(env_path: Path) -> Optional[dict]:
 
 
 def resolve_env_path(node_dir: Path) -> Tuple[Optional[Path], Optional[Path], Optional[Path]]:
-    """
-    Resolve environment path with fallback chain.
-
-    Args:
-        node_dir: Directory containing comfy-env.toml or marker file
-
-    Returns:
-        (env_path, site_packages, lib_dir) or (None, None, None)
-
-    Fallback order:
-        1. Marker file -> central cache
-        2. _env_<name> (current location)
-        3. .pixi/envs/default (old pixi)
-        4. .venv (venv support)
-    """
+    """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)
@@ -263,15 +154,7 @@ def resolve_env_path(node_dir: Path) -> Tuple[Optional[Path], Optional[Path], Op
 
 
 def _get_env_paths(env_path: Path) -> Tuple[Path, Optional[Path], Optional[Path]]:
-    """
-    Get site-packages and lib paths from an environment.
-
-    Args:
-        env_path: Path to environment root
-
-    Returns:
-        (env_path, site_packages, lib_dir)
-    """
+    """Get site-packages and lib paths from an environment."""
     import glob
 
     if sys.platform == "win32":
@@ -287,18 +170,7 @@ def _get_env_paths(env_path: Path) -> Tuple[Path, Optional[Path], Optional[Path]
 
 
 def cleanup_orphaned_envs(log: Callable[[str], None] = print) -> int:
-    """
-    Scan central cache and remove orphaned environments.
-
-    An env is orphaned if its marker file no longer exists
-    (meaning the node was deleted).
-
-    Args:
-        log: Logging function
-
-    Returns:
-        Number of envs cleaned up
-    """
+    """Remove orphaned environments. Returns count cleaned."""
     cache_dir = get_cache_dir()
     if not cache_dir.exists():
         return 0

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],