comfy-env 0.1.16__tar.gz → 0.1.17__tar.gz

comfy_env-0.1.17/PKG-INFO

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: comfy-env
+Version: 0.1.17
+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
+Project-URL: Issues, https://github.com/PozzettiAndrea/comfy-env/issues
+Author: Andrea Pozzetti
+License: MIT
+License-File: LICENSE
+Keywords: comfyui,cuda,environment,isolation,process,venv,wheels
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: pip>=21.0
+Requires-Dist: tomli-w>=1.0.0
+Requires-Dist: tomli>=2.0.0
+Requires-Dist: uv>=0.4.0
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# comfy-env
+
+Environment management for ComfyUI custom nodes.
+
+## Quick Start
+
+```bash
+pip install comfy-env
+```
+
+**1. Create `comfy-env-root.toml` in your node directory:**
+
+```toml
+[cuda]
+packages = ["nvdiffrast", "pytorch3d"]
+
+[apt]
+packages = ["libgl1-mesa-glx"]
+
+[node_reqs]
+ComfyUI_essentials = "cubiq/ComfyUI_essentials"
+```
+
+PyPI deps go in `requirements.txt` (standard ComfyUI pattern).
+
+**2. In `install.py`:**
+
+```python
+from comfy_env import install
+install()
+```
+
+**3. In `prestartup_script.py`:**
+
+```python
+from comfy_env import setup_env
+setup_env()
+```
+
+---
+
+## Two Config Files
+
+| File | Purpose |
+|------|---------|
+| `comfy-env-root.toml` | Main node config (root level) |
+| `comfy-env.toml` | Isolated subfolder config |
+
+### comfy-env-root.toml (main node)
+
+```toml
+[cuda]
+packages = ["nvdiffrast", "pytorch3d"]
+
+[apt]
+packages = ["libgl1-mesa-glx"]
+
+[dependencies]
+cgal = "*"
+
+[env_vars]
+KMP_DUPLICATE_LIB_OK = "TRUE"
+
+[node_reqs]
+ComfyUI_essentials = "cubiq/ComfyUI_essentials"
+```
+
+PyPI deps → `requirements.txt`
+
+### comfy-env.toml (isolated folder)
+
+```toml
+python = "3.11"
+
+[dependencies]
+cgal = "*"
+
+[pypi-dependencies]
+trimesh = { version = "*", extras = ["easy"] }
+
+[env_vars]
+SOME_VAR = "value"
+```
+
+### What goes where?
+
+| Section | Root | Isolated |
+|---------|------|----------|
+| `[cuda]` | ✓ | ✓ |
+| `[apt]` | ✓ | ✓ |
+| `[dependencies]` | ✓ | ✓ |
+| `[env_vars]` | ✓ | ✓ |
+| `[node_reqs]` | ✓ | ✗ |
+| `python = "X.Y"` | ✗ | ✓ |
+| `[pypi-dependencies]` | ✗ | ✓ |
+
+---
+
+## Process Isolation
+
+For nodes with conflicting dependencies:
+
+```python
+# In nodes/__init__.py
+from pathlib import Path
+from comfy_env import wrap_isolated_nodes
+
+from .cgal import NODE_CLASS_MAPPINGS as cgal_mappings
+
+NODE_CLASS_MAPPINGS = wrap_isolated_nodes(
+    cgal_mappings,
+    Path(__file__).parent / "cgal"  # Has comfy-env.toml
+)
+```
+
+Each wrapped node runs in a subprocess with its own Python environment.
+
+---
+
+## CLI
+
+```bash
+comfy-env init              # Create comfy-env-root.toml
+comfy-env init --isolated   # Create comfy-env.toml (for subfolders)
+comfy-env install           # Install dependencies
+comfy-env install --dry-run # Preview
+comfy-env info              # Show runtime info
+comfy-env doctor            # Verify packages
+comfy-env apt-install       # Install system packages
+```
+
+---
+
+## API
+
+### install()
+
+```python
+from comfy_env import install
+install()
+```
+
+### setup_env()
+
+```python
+from comfy_env import setup_env
+setup_env()  # Call in prestartup_script.py
+```
+
+### wrap_isolated_nodes()
+
+```python
+from comfy_env import wrap_isolated_nodes
+wrapped = wrap_isolated_nodes(NODE_CLASS_MAPPINGS, node_dir)
+```
+
+### Detection
+
+```python
+from comfy_env import RuntimeEnv, detect_cuda_version, detect_gpu
+
+env = RuntimeEnv.detect()
+print(env)  # Python 3.11, CUDA 12.8, PyTorch 2.8.0, GPU: RTX 4090
+```
+
+---
+
+## Example
+
+See [ComfyUI-GeometryPack](https://github.com/PozzettiAndrea/ComfyUI-GeometryPack):
+
+- Multiple isolated environments (CGAL, Blender, GPU)
+- Per-subdirectory `comfy-env.toml`
+- Different Python versions
+
+---
+
+## Why?
+
+**Why isolation?** ComfyUI nodes share one Python. Conflicts happen when:
+- Node A needs torch 2.4, Node B needs torch 2.8
+- Two packages bundle incompatible libomp
+- Blender API requires Python 3.11
+
+**Why CUDA wheels?** Installing nvdiffrast normally needs CUDA toolkit + C++ compiler + 30 min compilation. [cuda-wheels](https://pozzettiandrea.github.io/cuda-wheels/) provides pre-built wheels.
+
+**How envs work:**
+- Central cache: `~/.comfy-env/envs/`
+- Marker files link nodes → cached envs
+- Config hash in name → changes create new envs
+
+---
+
+## License
+
+MIT

comfy_env-0.1.17/README.md

@@ -0,0 +1,196 @@
+# comfy-env
+
+Environment management for ComfyUI custom nodes.
+
+## Quick Start
+
+```bash
+pip install comfy-env
+```
+
+**1. Create `comfy-env-root.toml` in your node directory:**
+
+```toml
+[cuda]
+packages = ["nvdiffrast", "pytorch3d"]
+
+[apt]
+packages = ["libgl1-mesa-glx"]
+
+[node_reqs]
+ComfyUI_essentials = "cubiq/ComfyUI_essentials"
+```
+
+PyPI deps go in `requirements.txt` (standard ComfyUI pattern).
+
+**2. In `install.py`:**
+
+```python
+from comfy_env import install
+install()
+```
+
+**3. In `prestartup_script.py`:**
+
+```python
+from comfy_env import setup_env
+setup_env()
+```
+
+---
+
+## Two Config Files
+
+| File | Purpose |
+|------|---------|
+| `comfy-env-root.toml` | Main node config (root level) |
+| `comfy-env.toml` | Isolated subfolder config |
+
+### comfy-env-root.toml (main node)
+
+```toml
+[cuda]
+packages = ["nvdiffrast", "pytorch3d"]
+
+[apt]
+packages = ["libgl1-mesa-glx"]
+
+[dependencies]
+cgal = "*"
+
+[env_vars]
+KMP_DUPLICATE_LIB_OK = "TRUE"
+
+[node_reqs]
+ComfyUI_essentials = "cubiq/ComfyUI_essentials"
+```
+
+PyPI deps → `requirements.txt`
+
+### comfy-env.toml (isolated folder)
+
+```toml
+python = "3.11"
+
+[dependencies]
+cgal = "*"
+
+[pypi-dependencies]
+trimesh = { version = "*", extras = ["easy"] }
+
+[env_vars]
+SOME_VAR = "value"
+```
+
+### What goes where?
+
+| Section | Root | Isolated |
+|---------|------|----------|
+| `[cuda]` | ✓ | ✓ |
+| `[apt]` | ✓ | ✓ |
+| `[dependencies]` | ✓ | ✓ |
+| `[env_vars]` | ✓ | ✓ |
+| `[node_reqs]` | ✓ | ✗ |
+| `python = "X.Y"` | ✗ | ✓ |
+| `[pypi-dependencies]` | ✗ | ✓ |
+
+---
+
+## Process Isolation
+
+For nodes with conflicting dependencies:
+
+```python
+# In nodes/__init__.py
+from pathlib import Path
+from comfy_env import wrap_isolated_nodes
+
+from .cgal import NODE_CLASS_MAPPINGS as cgal_mappings
+
+NODE_CLASS_MAPPINGS = wrap_isolated_nodes(
+    cgal_mappings,
+    Path(__file__).parent / "cgal"  # Has comfy-env.toml
+)
+```
+
+Each wrapped node runs in a subprocess with its own Python environment.
+
+---
+
+## CLI
+
+```bash
+comfy-env init              # Create comfy-env-root.toml
+comfy-env init --isolated   # Create comfy-env.toml (for subfolders)
+comfy-env install           # Install dependencies
+comfy-env install --dry-run # Preview
+comfy-env info              # Show runtime info
+comfy-env doctor            # Verify packages
+comfy-env apt-install       # Install system packages
+```
+
+---
+
+## API
+
+### install()
+
+```python
+from comfy_env import install
+install()
+```
+
+### setup_env()
+
+```python
+from comfy_env import setup_env
+setup_env()  # Call in prestartup_script.py
+```
+
+### wrap_isolated_nodes()
+
+```python
+from comfy_env import wrap_isolated_nodes
+wrapped = wrap_isolated_nodes(NODE_CLASS_MAPPINGS, node_dir)
+```
+
+### Detection
+
+```python
+from comfy_env import RuntimeEnv, detect_cuda_version, detect_gpu
+
+env = RuntimeEnv.detect()
+print(env)  # Python 3.11, CUDA 12.8, PyTorch 2.8.0, GPU: RTX 4090
+```
+
+---
+
+## Example
+
+See [ComfyUI-GeometryPack](https://github.com/PozzettiAndrea/ComfyUI-GeometryPack):
+
+- Multiple isolated environments (CGAL, Blender, GPU)
+- Per-subdirectory `comfy-env.toml`
+- Different Python versions
+
+---
+
+## Why?
+
+**Why isolation?** ComfyUI nodes share one Python. Conflicts happen when:
+- Node A needs torch 2.4, Node B needs torch 2.8
+- Two packages bundle incompatible libomp
+- Blender API requires Python 3.11
+
+**Why CUDA wheels?** Installing nvdiffrast normally needs CUDA toolkit + C++ compiler + 30 min compilation. [cuda-wheels](https://pozzettiandrea.github.io/cuda-wheels/) provides pre-built wheels.
+
+**How envs work:**
+- Central cache: `~/.comfy-env/envs/`
+- Marker files link nodes → cached envs
+- Config hash in name → changes create new envs
+
+---
+
+## License
+
+MIT

{comfy_env-0.1.16 → comfy_env-0.1.17}/pyproject.toml

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

{comfy_env-0.1.16 → comfy_env-0.1.17}/src/comfy_env/__init__.py

@@ -37,10 +37,11 @@ from .isolation import wrap_isolated_nodes, wrap_nodes
 from .config import (
     ComfyEnvConfig,
     NodeDependency,
-    NodeReq,  # Backwards compatibility alias
+    NodeReq,
     load_config,
     discover_config,
     CONFIG_FILE_NAME,
+    ROOT_CONFIG_FILE_NAME,
 )
 
 
@@ -136,6 +137,7 @@ __all__ = [
     "load_config",
     "discover_config",
     "CONFIG_FILE_NAME",
+    "ROOT_CONFIG_FILE_NAME",
     # Detection
     "detect_cuda_version",
     "detect_cuda_environment",

{comfy_env-0.1.16 → comfy_env-0.1.17}/src/comfy_env/cli.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import List, Optional
 
 from . import __version__
+from .config import ROOT_CONFIG_FILE_NAME, CONFIG_FILE_NAME
 
 
 def main(args: Optional[List[str]] = None) -> int:
@@ -14,12 +15,13 @@ def main(args: Optional[List[str]] = None) -> int:
     sub = parser.add_subparsers(dest="command", help="Commands")
 
     # init
-    p = sub.add_parser("init", help="Create comfy-env.toml")
+    p = sub.add_parser("init", help=f"Create {ROOT_CONFIG_FILE_NAME}")
     p.add_argument("--force", "-f", action="store_true", help="Overwrite existing")
+    p.add_argument("--isolated", action="store_true", help=f"Create {CONFIG_FILE_NAME} instead (for isolated folders)")
 
     # generate
-    p = sub.add_parser("generate", help="Generate pixi.toml from comfy-env.toml")
-    p.add_argument("config", type=str, help="Path to comfy-env.toml")
+    p = sub.add_parser("generate", help="Generate pixi.toml from config")
+    p.add_argument("config", type=str, help="Path to config file")
     p.add_argument("--force", "-f", action="store_true", help="Overwrite existing")
 
     # install
@@ -62,22 +64,53 @@ def main(args: Optional[List[str]] = None) -> int:
         return 1
 
 
-DEFAULT_CONFIG = """\
-# comfy-env.toml
+ROOT_DEFAULT_CONFIG = """\
+# comfy-env-root.toml - Main node config
+# PyPI deps go in requirements.txt
+
 [cuda]
 packages = []
 
+[apt]
+packages = []
+
+[dependencies]
+# cgal = "*"
+
+[env_vars]
+# KMP_DUPLICATE_LIB_OK = "TRUE"
+
+[node_reqs]
+# ComfyUI_essentials = "cubiq/ComfyUI_essentials"
+"""
+
+ISOLATED_DEFAULT_CONFIG = """\
+# comfy-env.toml - Isolated folder config
+python = "3.11"
+
+[dependencies]
+# cgal = "*"
+
 [pypi-dependencies]
-# example = "*"
+# trimesh = { version = "*", extras = ["easy"] }
+
+[env_vars]
+# SOME_VAR = "value"
 """
 
 
 def cmd_init(args) -> int:
-    config_path = Path.cwd() / "comfy-env.toml"
+    if getattr(args, 'isolated', False):
+        config_path = Path.cwd() / CONFIG_FILE_NAME
+        content = ISOLATED_DEFAULT_CONFIG
+    else:
+        config_path = Path.cwd() / ROOT_CONFIG_FILE_NAME
+        content = ROOT_DEFAULT_CONFIG
+
     if config_path.exists() and not args.force:
         print(f"Already exists: {config_path}\nUse --force to overwrite", file=sys.stderr)
         return 1
-    config_path.write_text(DEFAULT_CONFIG)
+    config_path.write_text(content)
     print(f"Created {config_path}")
     return 0
 
@@ -170,7 +203,13 @@ def cmd_apt_install(args) -> int:
         print("apt-install: Linux only", file=sys.stderr)
         return 1
 
-    config_path = Path(args.config).resolve() if args.config else Path.cwd() / "comfy-env.toml"
+    # Check root config first, then regular
+    if args.config:
+        config_path = Path(args.config).resolve()
+    else:
+        root_path = Path.cwd() / ROOT_CONFIG_FILE_NAME
+        config_path = root_path if root_path.exists() else Path.cwd() / CONFIG_FILE_NAME
+
     if not config_path.exists():
         print(f"Not found: {config_path}", file=sys.stderr)
         return 1

{comfy_env-0.1.16 → comfy_env-0.1.17}/src/comfy_env/config/__init__.py

@@ -1,15 +1,12 @@
-"""
-Config layer - Configuration parsing and types.
-
-Pure parsing, no side effects.
-"""
+"""Config layer - Configuration parsing and types."""
 
 from .types import (
     ComfyEnvConfig,
     NodeDependency,
-    NodeReq,  # Backwards compatibility alias
+    NodeReq,
 )
 from .parser import (
+    ROOT_CONFIG_FILE_NAME,
     CONFIG_FILE_NAME,
     load_config,
     discover_config,
@@ -17,11 +14,10 @@ from .parser import (
 )
 
 __all__ = [
-    # Types
     "ComfyEnvConfig",
     "NodeDependency",
-    "NodeReq",  # Backwards compatibility
-    # Parsing
+    "NodeReq",
+    "ROOT_CONFIG_FILE_NAME",
     "CONFIG_FILE_NAME",
     "load_config",
     "discover_config",

{comfy_env-0.1.16 → comfy_env-0.1.17}/src/comfy_env/config/parser.py

@@ -8,11 +8,12 @@ import tomli
 
 from .types import ComfyEnvConfig, NodeDependency
 
-CONFIG_FILE_NAME = "comfy-env.toml"
+ROOT_CONFIG_FILE_NAME = "comfy-env-root.toml"  # Main node config
+CONFIG_FILE_NAME = "comfy-env.toml"  # Isolated folder config
 
 
 def load_config(path: Path) -> ComfyEnvConfig:
-    """Load and parse comfy-env.toml."""
+    """Load and parse config file."""
     path = Path(path)
     if not path.exists():
         raise FileNotFoundError(f"Config file not found: {path}")
@@ -20,9 +21,14 @@ def load_config(path: Path) -> ComfyEnvConfig:
         return parse_config(tomli.load(f))
 
 
-def discover_config(node_dir: Path) -> Optional[ComfyEnvConfig]:
-    """Find and load comfy-env.toml from directory."""
-    config_path = Path(node_dir) / CONFIG_FILE_NAME
+def discover_config(node_dir: Path, root: bool = True) -> Optional[ComfyEnvConfig]:
+    """Find and load config from directory. Checks root config first if root=True."""
+    node_dir = Path(node_dir)
+    if root:
+        root_path = node_dir / ROOT_CONFIG_FILE_NAME
+        if root_path.exists():
+            return load_config(root_path)
+    config_path = node_dir / CONFIG_FILE_NAME
     return load_config(config_path) if config_path.exists() else None
 
 
@@ -49,7 +55,6 @@ def parse_config(data: Dict[str, Any]) -> ComfyEnvConfig:
 
 
 def _parse_node_reqs(data: Dict[str, Any]) -> List[NodeDependency]:
-    """Parse [node_reqs] section."""
     return [
         NodeDependency(name=name, repo=value if isinstance(value, str) else value.get("repo", ""))
         for name, value in data.items()

{comfy_env-0.1.16 → comfy_env-0.1.17}/src/comfy_env/environment/setup.py

@@ -10,6 +10,7 @@ from .cache import MARKER_FILE, sanitize_name
 from .libomp import dedupe_libomp
 
 USE_COMFY_ENV_VAR = "USE_COMFY_ENV"
+ROOT_CONFIG_FILE_NAME = "comfy-env-root.toml"
 
 
 def is_comfy_env_enabled() -> bool:
@@ -50,8 +51,10 @@ def setup_env(node_dir: Optional[str] = None) -> None:
         import inspect
         node_dir = str(Path(inspect.stack()[1].filename).parent)
 
-    # Apply env vars
-    for k, v in load_env_vars(os.path.join(node_dir, "comfy-env.toml")).items():
+    # Apply env vars (check root config first, then regular)
+    root_config = os.path.join(node_dir, ROOT_CONFIG_FILE_NAME)
+    config = root_config if os.path.exists(root_config) else os.path.join(node_dir, "comfy-env.toml")
+    for k, v in load_env_vars(config).items():
         os.environ[k] = v
 
     # Find env: marker -> _env_<name> -> .pixi

{comfy_env-0.1.16 → comfy_env-0.1.17}/src/comfy_env/install.py

@@ -5,7 +5,7 @@ import os
 from pathlib import Path
 from typing import Callable, List, Optional, Set, Union
 
-from .config import ComfyEnvConfig, NodeDependency, load_config, discover_config, CONFIG_FILE_NAME
+from .config import ComfyEnvConfig, NodeDependency, load_config, discover_config, CONFIG_FILE_NAME, ROOT_CONFIG_FILE_NAME
 
 USE_COMFY_ENV_VAR = "USE_COMFY_ENV"
 
@@ -20,7 +20,7 @@ def install(
     log_callback: Optional[Callable[[str], None]] = None,
     dry_run: bool = False,
 ) -> bool:
-    """Install dependencies from comfy-env.toml."""
+    """Install dependencies from comfy-env-root.toml or comfy-env.toml."""
     if node_dir is None:
         node_dir = Path(inspect.stack()[1].filename).parent.resolve()
 
@@ -32,10 +32,10 @@ def install(
             config_path = node_dir / config_path
         cfg = load_config(config_path)
     else:
-        cfg = discover_config(node_dir)
+        cfg = discover_config(node_dir, root=True)
 
     if cfg is None:
-        raise FileNotFoundError(f"No comfy-env.toml found in {node_dir}")
+        raise FileNotFoundError(f"No {ROOT_CONFIG_FILE_NAME} or {CONFIG_FILE_NAME} found in {node_dir}")
 
     if cfg.apt_packages: _install_apt_packages(cfg.apt_packages, log, dry_run)
     if cfg.env_vars: _set_persistent_env_vars(cfg.env_vars, log, dry_run)
@@ -168,8 +168,12 @@ def _install_via_pixi(cfg: ComfyEnvConfig, node_dir: Path, log: Callable[[str],
             if result.returncode != 0:
                 raise RuntimeError(f"Failed: {result.stderr}")
 
+    # Find config file for marker
+    config_path = node_dir / CONFIG_FILE_NAME
+    if not config_path.exists():
+        config_path = node_dir / ROOT_CONFIG_FILE_NAME
+
     old_env = node_dir / ".pixi" / "envs" / "default"
-    config_path = node_dir / "comfy-env.toml"
     main_node_dir = node_dir
     for parent in node_dir.parents:
         if parent.parent.name == "custom_nodes":
@@ -229,8 +233,9 @@ def _install_to_host_python(cfg: ComfyEnvConfig, node_dir: Path, log: Callable[[
 
 
 def _install_isolated_subdirs(node_dir: Path, log: Callable[[str], None], dry_run: bool) -> None:
+    """Find and install comfy-env.toml in subdirectories (isolated folders only)."""
     for config_file in node_dir.rglob(CONFIG_FILE_NAME):
-        if config_file.parent == node_dir: continue
+        if config_file.parent == node_dir: continue  # Skip root
         log(f"\n[isolated] {config_file.parent.relative_to(node_dir)}")
         if not dry_run:
             _install_via_pixi(load_config(config_file), config_file.parent, log, dry_run)

comfy_env-0.1.16/PKG-INFO

@@ -1,279 +0,0 @@
-Metadata-Version: 2.4
-Name: comfy-env
-Version: 0.1.16
-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
-Project-URL: Issues, https://github.com/PozzettiAndrea/comfy-env/issues
-Author: Andrea Pozzetti
-License: MIT
-License-File: LICENSE
-Keywords: comfyui,cuda,environment,isolation,process,venv,wheels
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
-Requires-Dist: pip>=21.0
-Requires-Dist: tomli-w>=1.0.0
-Requires-Dist: tomli>=2.0.0
-Requires-Dist: uv>=0.4.0
-Provides-Extra: dev
-Requires-Dist: mypy; extra == 'dev'
-Requires-Dist: pytest; extra == 'dev'
-Requires-Dist: ruff; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# comfy-env
-
-Environment management for ComfyUI custom nodes.
-
-## Quick Start
-
-```bash
-pip install comfy-env
-```
-
-**1. Create `comfy-env.toml` in your node directory:**
-
-```toml
-[cuda]
-packages = ["nvdiffrast", "pytorch3d"]
-
-[pypi-dependencies]
-trimesh = { version = "*", extras = ["easy"] }
-```
-
-**2. In `install.py`:**
-
-```python
-from comfy_env import install
-install()
-```
-
-**3. In `prestartup_script.py`:**
-
-```python
-from comfy_env import setup_env
-setup_env()
-```
-
-That's it. CUDA wheels install without compilation, and the environment is ready.
-
----
-
-## Configuration
-
-Create `comfy-env.toml` in your node directory:
-
-```toml
-# Python version for isolated environment (optional)
-python = "3.11"
-
-# CUDA packages from cuda-wheels index (no compilation needed)
-[cuda]
-packages = ["nvdiffrast", "pytorch3d", "flash-attn"]
-
-# System packages (Linux only)
-[apt]
-packages = ["libgl1-mesa-glx", "libglu1-mesa"]
-
-# Environment variables
-[env_vars]
-KMP_DUPLICATE_LIB_OK = "TRUE"
-OMP_NUM_THREADS = "1"
-
-# Dependent custom nodes to auto-install
-[node_reqs]
-ComfyUI_essentials = "cubiq/ComfyUI_essentials"
-
-# Conda packages (via pixi)
-[dependencies]
-cgal = "*"
-
-# PyPI packages
-[pypi-dependencies]
-trimesh = { version = "*", extras = ["easy"] }
-numpy = "*"
-```
-
----
-
-## Process Isolation
-
-For nodes with conflicting dependencies, use isolated execution:
-
-```python
-# In nodes/__init__.py
-from pathlib import Path
-from comfy_env import wrap_isolated_nodes
-
-# Import your isolated nodes
-from .cgal import NODE_CLASS_MAPPINGS as cgal_mappings
-
-# Wrap them for isolated execution
-NODE_CLASS_MAPPINGS = wrap_isolated_nodes(
-    cgal_mappings,
-    Path(__file__).parent / "cgal"  # Directory with comfy-env.toml
-)
-```
-
-Each wrapped node runs in a subprocess with its own Python environment.
-
----
-
-## CLI Commands
-
-```bash
-# Show detected environment
-comfy-env info
-
-# Install dependencies
-comfy-env install
-
-# Preview without installing
-comfy-env install --dry-run
-
-# Verify packages
-comfy-env doctor
-
-# Install system packages
-comfy-env apt-install
-```
-
----
-
-## API Reference
-
-### install()
-
-Install dependencies from comfy-env.toml:
-
-```python
-from comfy_env import install
-
-install()                    # Auto-detect config
-install(dry_run=True)        # Preview only
-install(config="path.toml")  # Explicit config
-```
-
-### setup_env()
-
-Set up environment at ComfyUI startup:
-
-```python
-from comfy_env import setup_env
-
-setup_env()  # Auto-detects node directory from caller
-```
-
-Sets library paths, environment variables, and injects site-packages.
-
-### wrap_isolated_nodes()
-
-Wrap nodes for subprocess isolation:
-
-```python
-from comfy_env import wrap_isolated_nodes
-
-wrapped = wrap_isolated_nodes(NODE_CLASS_MAPPINGS, node_dir)
-```
-
-### Detection
-
-```python
-from comfy_env import (
-    detect_cuda_version,      # Returns "12.8", "12.4", or None
-    detect_gpu,               # Returns GPUInfo or None
-    get_gpu_summary,          # Human-readable string
-    RuntimeEnv,               # Combined runtime info
-)
-
-env = RuntimeEnv.detect()
-print(env)  # Python 3.11, CUDA 12.8, PyTorch 2.8.0, GPU: RTX 4090
-```
-
-### Workers
-
-Low-level process isolation:
-
-```python
-from comfy_env import MPWorker, SubprocessWorker
-
-# Same Python version (multiprocessing)
-worker = MPWorker()
-result = worker.call(my_function, arg1, arg2)
-
-# Different Python version (subprocess)
-worker = SubprocessWorker(python="/path/to/python")
-result = worker.call(my_function, arg1, arg2)
-```
-
----
-
-## Real Example
-
-See [ComfyUI-GeometryPack](https://github.com/PozzettiAndrea/ComfyUI-GeometryPack) for a production example with:
-
-- Multiple isolated environments (CGAL, Blender, GPU)
-- Per-subdirectory comfy-env.toml
-- Prestartup asset copying
-- Different Python versions (3.11 for Blender API)
-
----
-
-## Architecture
-
-### Layers
-
-```
-comfy_env/
-├── detection/     # Pure functions - CUDA, GPU, platform detection
-├── config/        # Pure parsing - comfy-env.toml → typed config
-├── environment/   # Side effects - cache, paths, setup
-├── packages/      # Side effects - pixi, cuda-wheels, apt
-├── isolation/     # Side effects - subprocess workers, node wrapping
-└── install.py     # Orchestration
-```
-
-### Why Isolation?
-
-ComfyUI nodes share a single Python environment. This breaks when:
-
-1. **Dependency conflicts**: Node A needs `torch==2.4`, Node B needs `torch==2.8`
-2. **Native library conflicts**: Two packages bundle incompatible libomp
-3. **Python version requirements**: Blender API requires Python 3.11
-
-Solution: Run each node group in its own subprocess with isolated dependencies.
-
-### Why CUDA Wheels?
-
-Installing packages like `nvdiffrast` normally requires:
-- CUDA toolkit
-- C++ compiler
-- 30+ minutes of compilation
-
-CUDA wheels from [cuda-wheels](https://pozzettiandrea.github.io/cuda-wheels/) are pre-built for common configurations:
-
-| GPU | CUDA | PyTorch |
-|-----|------|---------|
-| Blackwell (sm_100+) | 12.8 | 2.8 |
-| Ada/Hopper/Ampere | 12.8 | 2.8 |
-| Turing | 12.8 | 2.8 |
-| Pascal | 12.4 | 2.4 |
-
-### How Environments Work
-
-1. **Central cache**: Environments stored at `~/.comfy-env/envs/`
-2. **Marker files**: `.comfy-env-marker.toml` links node → env
-3. **Orphan cleanup**: Envs deleted when their node is removed
-4. **Hash-based naming**: Config changes create new envs
-
----
-
-## License
-
-MIT

comfy_env-0.1.16/README.md

@@ -1,250 +0,0 @@
-# comfy-env
-
-Environment management for ComfyUI custom nodes.
-
-## Quick Start
-
-```bash
-pip install comfy-env
-```
-
-**1. Create `comfy-env.toml` in your node directory:**
-
-```toml
-[cuda]
-packages = ["nvdiffrast", "pytorch3d"]
-
-[pypi-dependencies]
-trimesh = { version = "*", extras = ["easy"] }
-```
-
-**2. In `install.py`:**
-
-```python
-from comfy_env import install
-install()
-```
-
-**3. In `prestartup_script.py`:**
-
-```python
-from comfy_env import setup_env
-setup_env()
-```
-
-That's it. CUDA wheels install without compilation, and the environment is ready.
-
----
-
-## Configuration
-
-Create `comfy-env.toml` in your node directory:
-
-```toml
-# Python version for isolated environment (optional)
-python = "3.11"
-
-# CUDA packages from cuda-wheels index (no compilation needed)
-[cuda]
-packages = ["nvdiffrast", "pytorch3d", "flash-attn"]
-
-# System packages (Linux only)
-[apt]
-packages = ["libgl1-mesa-glx", "libglu1-mesa"]
-
-# Environment variables
-[env_vars]
-KMP_DUPLICATE_LIB_OK = "TRUE"
-OMP_NUM_THREADS = "1"
-
-# Dependent custom nodes to auto-install
-[node_reqs]
-ComfyUI_essentials = "cubiq/ComfyUI_essentials"
-
-# Conda packages (via pixi)
-[dependencies]
-cgal = "*"
-
-# PyPI packages
-[pypi-dependencies]
-trimesh = { version = "*", extras = ["easy"] }
-numpy = "*"
-```
-
----
-
-## Process Isolation
-
-For nodes with conflicting dependencies, use isolated execution:
-
-```python
-# In nodes/__init__.py
-from pathlib import Path
-from comfy_env import wrap_isolated_nodes
-
-# Import your isolated nodes
-from .cgal import NODE_CLASS_MAPPINGS as cgal_mappings
-
-# Wrap them for isolated execution
-NODE_CLASS_MAPPINGS = wrap_isolated_nodes(
-    cgal_mappings,
-    Path(__file__).parent / "cgal"  # Directory with comfy-env.toml
-)
-```
-
-Each wrapped node runs in a subprocess with its own Python environment.
-
----
-
-## CLI Commands
-
-```bash
-# Show detected environment
-comfy-env info
-
-# Install dependencies
-comfy-env install
-
-# Preview without installing
-comfy-env install --dry-run
-
-# Verify packages
-comfy-env doctor
-
-# Install system packages
-comfy-env apt-install
-```
-
----
-
-## API Reference
-
-### install()
-
-Install dependencies from comfy-env.toml:
-
-```python
-from comfy_env import install
-
-install()                    # Auto-detect config
-install(dry_run=True)        # Preview only
-install(config="path.toml")  # Explicit config
-```
-
-### setup_env()
-
-Set up environment at ComfyUI startup:
-
-```python
-from comfy_env import setup_env
-
-setup_env()  # Auto-detects node directory from caller
-```
-
-Sets library paths, environment variables, and injects site-packages.
-
-### wrap_isolated_nodes()
-
-Wrap nodes for subprocess isolation:
-
-```python
-from comfy_env import wrap_isolated_nodes
-
-wrapped = wrap_isolated_nodes(NODE_CLASS_MAPPINGS, node_dir)
-```
-
-### Detection
-
-```python
-from comfy_env import (
-    detect_cuda_version,      # Returns "12.8", "12.4", or None
-    detect_gpu,               # Returns GPUInfo or None
-    get_gpu_summary,          # Human-readable string
-    RuntimeEnv,               # Combined runtime info
-)
-
-env = RuntimeEnv.detect()
-print(env)  # Python 3.11, CUDA 12.8, PyTorch 2.8.0, GPU: RTX 4090
-```
-
-### Workers
-
-Low-level process isolation:
-
-```python
-from comfy_env import MPWorker, SubprocessWorker
-
-# Same Python version (multiprocessing)
-worker = MPWorker()
-result = worker.call(my_function, arg1, arg2)
-
-# Different Python version (subprocess)
-worker = SubprocessWorker(python="/path/to/python")
-result = worker.call(my_function, arg1, arg2)
-```
-
----
-
-## Real Example
-
-See [ComfyUI-GeometryPack](https://github.com/PozzettiAndrea/ComfyUI-GeometryPack) for a production example with:
-
-- Multiple isolated environments (CGAL, Blender, GPU)
-- Per-subdirectory comfy-env.toml
-- Prestartup asset copying
-- Different Python versions (3.11 for Blender API)
-
----
-
-## Architecture
-
-### Layers
-
-```
-comfy_env/
-├── detection/     # Pure functions - CUDA, GPU, platform detection
-├── config/        # Pure parsing - comfy-env.toml → typed config
-├── environment/   # Side effects - cache, paths, setup
-├── packages/      # Side effects - pixi, cuda-wheels, apt
-├── isolation/     # Side effects - subprocess workers, node wrapping
-└── install.py     # Orchestration
-```
-
-### Why Isolation?
-
-ComfyUI nodes share a single Python environment. This breaks when:
-
-1. **Dependency conflicts**: Node A needs `torch==2.4`, Node B needs `torch==2.8`
-2. **Native library conflicts**: Two packages bundle incompatible libomp
-3. **Python version requirements**: Blender API requires Python 3.11
-
-Solution: Run each node group in its own subprocess with isolated dependencies.
-
-### Why CUDA Wheels?
-
-Installing packages like `nvdiffrast` normally requires:
-- CUDA toolkit
-- C++ compiler
-- 30+ minutes of compilation
-
-CUDA wheels from [cuda-wheels](https://pozzettiandrea.github.io/cuda-wheels/) are pre-built for common configurations:
-
-| GPU | CUDA | PyTorch |
-|-----|------|---------|
-| Blackwell (sm_100+) | 12.8 | 2.8 |
-| Ada/Hopper/Ampere | 12.8 | 2.8 |
-| Turing | 12.8 | 2.8 |
-| Pascal | 12.4 | 2.4 |
-
-### How Environments Work
-
-1. **Central cache**: Environments stored at `~/.comfy-env/envs/`
-2. **Marker files**: `.comfy-env-marker.toml` links node → env
-3. **Orphan cleanup**: Envs deleted when their node is removed
-4. **Hash-based naming**: Config changes create new envs
-
----
-
-## License
-
-MIT