comfy-env 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

comfy_env-0.1.16.dist-info/METADATA

@@ -0,0 +1,279 @@
+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.dist-info/RECORD

@@ -0,0 +1,36 @@
+comfy_env/__init__.py,sha256=uoHq-m1274tOeinWsIpW81MkRQilHx9z8_coJSqH9qc,4641
+comfy_env/cli.py,sha256=abdUBItk8OkzxKBu7cKRPizO5_i5DFflvx7pYpPc7OM,6696
+comfy_env/install.py,sha256=BV8OfY3Rt-BiKFzpDNHfs4mfLYalbsiIMNU-y9CmLDg,10467
+comfy_env/config/__init__.py,sha256=noqhycE0UF4ZntV5NnWcFApppQludQDHvJOtLsQgUIo,542
+comfy_env/config/parser.py,sha256=79C8LIwCO4920MU7CJ08hfMWh-5Ehzr-i5XQna5K81A,1951
+comfy_env/config/types.py,sha256=vFgWeEl_p26OmcoUv0wAOlHe9GBio2isjIWl7kACKFY,1096
+comfy_env/detection/__init__.py,sha256=dH84PlSRJfs8MRJp2gp9_NX8ZzGIDHR8iZXy7_B8Ez4,1671
+comfy_env/detection/cuda.py,sha256=BOaRQOGP2yoaPCO9eqPvWBB5Us_MNo-sSbadQsIjHqM,1708
+comfy_env/detection/gpu.py,sha256=Rf7pgtZXzUbJqcXzZXQi-yK5naeuSP1FiL6SdreeADM,8393
+comfy_env/detection/platform.py,sha256=Xe01dIZm7JT19kIH-j11h7KIBVRaKTLh8u4TzI3uZ6E,2127
+comfy_env/detection/runtime.py,sha256=gDplni7ZPGW7WjNJuqWbtgSwkWz27kBWSFvYbhXun6o,3756
+comfy_env/environment/__init__.py,sha256=WfZnyOvbI0MrDQPYTtOG2kHn0XCSCrqKcOlJcmB29nU,1009
+comfy_env/environment/cache.py,sha256=RGfVW2caMO0Dd1nX2otUQP0xW3pVS7iSOP4vIUAMdEA,4568
+comfy_env/environment/libomp.py,sha256=nzr3kDnRLgcf9CZ_WF4ItWskqEDS2S0geqZS43XoKig,1319
+comfy_env/environment/paths.py,sha256=5TFFAkOZXa8R3cHfVHDEFnwy6_JcHilVBOHJuy-yqR0,1129
+comfy_env/environment/setup.py,sha256=34To-cJX85sZ5W33dxcNosedrrICNUzVzqBcJkq4FLI,3013
+comfy_env/isolation/__init__.py,sha256=XfMLEiBIcEzHG_k2vk9fT9GvFfmOsfbpM26czuxbdRI,800
+comfy_env/isolation/tensor_utils.py,sha256=2_f4jjylqCPaPldD1Jw-es5CyOtuF5I1ROdyEIxsg-U,2951
+comfy_env/isolation/wrap.py,sha256=K7GAkqU_Uxe717eUtPsFv5kcr_Jfbh3x79A-8vbY1nY,8592
+comfy_env/isolation/workers/__init__.py,sha256=Zp6sZSRBcb5Negqgzqs3jPjfO9T1u3nNrQhp6WqTAuc,325
+comfy_env/isolation/workers/base.py,sha256=4ZYTaQ4J0kBHCoO_OfZnsowm4rJCoqinZUaOtgkOPbw,2307
+comfy_env/isolation/workers/mp.py,sha256=ygOgx2iyLN7l5fWkKI4lqzQsDyfAAd9Gb4gTYLp7o1A,34061
+comfy_env/isolation/workers/subprocess.py,sha256=ML6I9IenReagP8iT0Cd2ipet6JPK1gnDbOianOuFwOw,57164
+comfy_env/packages/__init__.py,sha256=6PTwUfUdJDTbIw46dCiA42qk4zUe_gw29xOaklBiMMc,1193
+comfy_env/packages/apt.py,sha256=pxy3A5ZHv3X8ExCVyohODY8Fcy9ji4izIVPfYoxhqT4,1027
+comfy_env/packages/cuda_wheels.py,sha256=G_CnlwNcfeWlEU24aCVBpeqQQ05y8_02dDLBwBFNwII,3980
+comfy_env/packages/node_dependencies.py,sha256=AX_CY6j43tTY5KhyPfU7Wz6zgLAfWF0o0JkTrcNSecg,2966
+comfy_env/packages/pixi.py,sha256=RPu8x5sSOLE1CYAhWMMjoQrbFGGt00fdsbqtRcTz7LQ,3871
+comfy_env/packages/toml_generator.py,sha256=Vhc8F9euHhMTwH1TV6t96-D9Pjrn9jIN4e9WXrCIFE8,3414
+comfy_env/templates/comfy-env-instructions.txt,sha256=ve1RAthW7ouumU9h6DM7mIRX1MS8_Tyonq2U4tcrFu8,1031
+comfy_env/templates/comfy-env.toml,sha256=ROIqi4BlPL1MEdL1VgebfTHpdwPNYGHwWeigI9Kw-1I,4831
+comfy_env-0.1.16.dist-info/METADATA,sha256=SLbnLOFz5AbqS8YT9-TWslRzo4QghO2EwUtQwn2B0OE,6468
+comfy_env-0.1.16.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.1.16.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.1.16.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.1.16.dist-info/RECORD,,

comfy_env/cache.py

@@ -1,331 +0,0 @@
-"""
-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.
-"""
-
-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"
-
-# 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
-
-
-# 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>
-
-    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)
-    """
-    # 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.
-
-    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
-
-    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 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()
-    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(),
-    }
-    metadata_path.write_text(tomli_w.dumps(metadata))
-
-
-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
-    """
-    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)
-    except Exception:
-        return None
-
-
-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
-    """
-    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)
-    except Exception:
-        return None
-
-
-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)
-    """
-    # 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.
-
-    Args:
-        env_path: Path to environment root
-
-    Returns:
-        (env_path, site_packages, lib_dir)
-    """
-    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:
-    """
-    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
-    """
-    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