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

comfy_env/workers/__init__.py

@@ -1,38 +0,0 @@
-"""
-Workers - Process isolation for ComfyUI nodes.
-
-This module provides two isolation tiers:
-
-Tier 1: MPWorker (same Python, fresh CUDA context)
-    - Uses multiprocessing.Queue
-    - Zero-copy tensor transfer via shared memory
-    - ~30ms overhead per call
-    - Use for: Memory isolation, fresh CUDA context
-
-Tier 2: SubprocessWorker (different Python/venv)
-    - Persistent subprocess + socket IPC
-    - ~50-100ms overhead per call
-    - Use for: Different PyTorch versions, incompatible deps
-
-Usage:
-    from comfy_env.workers import MPWorker, SubprocessWorker
-
-    # Create worker directly
-    worker = MPWorker()
-    result = worker.call(my_function, arg1, arg2)
-
-    # Or use SubprocessWorker for isolated Python
-    worker = SubprocessWorker(python="/path/to/venv/bin/python")
-    result = worker.call(my_function, image=tensor)
-"""
-
-from .base import Worker, WorkerError
-from .mp import MPWorker
-from .subprocess import SubprocessWorker
-
-__all__ = [
-    "Worker",
-    "WorkerError",
-    "MPWorker",
-    "SubprocessWorker",
-]

comfy_env/workers/tensor_utils.py

@@ -1,188 +0,0 @@
-"""
-Tensor utilities for robust IPC handling.
-
-Patterns borrowed from pyisolate (MIT licensed):
-- TensorKeeper: Prevents GC race conditions
-- CUDA IPC re-share detection: Graceful handling of received tensors
-"""
-
-import collections
-import logging
-import threading
-import time
-from typing import Any
-
-logger = logging.getLogger("comfy_env")
-
-
-# ---------------------------------------------------------------------------
-# TensorKeeper - Prevents GC Race Conditions
-# ---------------------------------------------------------------------------
-
-class TensorKeeper:
-    """
-    Keeps strong references to tensors during IPC to prevent premature GC.
-
-    Problem this solves:
-        When a tensor is serialized for IPC, the serialization returns
-        immediately but the receiving process may not have opened the
-        shared memory yet. If the sending process's tensor gets garbage
-        collected, the shared memory file is deleted, causing
-        "No such file or directory" errors on the receiver.
-
-    Solution:
-        Keep strong references to tensors for a configurable window
-        (default 30 seconds) to ensure the receiver has time to open them.
-
-    Usage:
-        keeper = TensorKeeper()
-        keeper.keep(tensor)  # Call before putting on queue
-    """
-
-    def __init__(self, retention_seconds: float = 30.0):
-        """
-        Args:
-            retention_seconds: How long to keep tensor references.
-                              30s is safe for slow systems.
-        """
-        self.retention_seconds = retention_seconds
-        self._keeper: collections.deque = collections.deque()
-        self._lock = threading.Lock()
-
-    def keep(self, t: Any) -> None:
-        """Keep a strong reference to tensor for retention_seconds."""
-        # Only keep torch tensors
-        try:
-            import torch
-            if not isinstance(t, torch.Tensor):
-                return
-        except ImportError:
-            return
-
-        now = time.time()
-        with self._lock:
-            self._keeper.append((now, t))
-
-            # Cleanup old entries
-            while self._keeper:
-                timestamp, _ = self._keeper[0]
-                if now - timestamp > self.retention_seconds:
-                    self._keeper.popleft()
-                else:
-                    break
-
-    def keep_recursive(self, obj: Any) -> None:
-        """Recursively keep all tensors in a nested structure."""
-        try:
-            import torch
-            if isinstance(obj, torch.Tensor):
-                self.keep(obj)
-            elif isinstance(obj, (list, tuple)):
-                for item in obj:
-                    self.keep_recursive(item)
-            elif isinstance(obj, dict):
-                for v in obj.values():
-                    self.keep_recursive(v)
-        except ImportError:
-            pass
-
-    def __len__(self) -> int:
-        """Return number of tensors currently being kept."""
-        with self._lock:
-            return len(self._keeper)
-
-
-# Global instance
-_tensor_keeper = TensorKeeper()
-
-
-def keep_tensor(t: Any) -> None:
-    """Keep a tensor reference to prevent GC during IPC."""
-    _tensor_keeper.keep(t)
-
-
-def keep_tensors_recursive(obj: Any) -> None:
-    """Keep all tensor references in a nested structure."""
-    _tensor_keeper.keep_recursive(obj)
-
-
-# ---------------------------------------------------------------------------
-# CUDA IPC Re-share Detection
-# ---------------------------------------------------------------------------
-
-def prepare_tensor_for_ipc(t: Any) -> Any:
-    """
-    Prepare a tensor for IPC, handling CUDA IPC re-share limitation.
-
-    Problem this solves:
-        Tensors received via CUDA IPC cannot be re-shared. If a node
-        receives a tensor via IPC and tries to return it, you get:
-        "RuntimeError: Attempted to send CUDA tensor received from
-        another process; this is not currently supported."
-
-    Solution:
-        Detect this situation and clone the tensor. Log a warning for
-        large tensors so users can optimize their pipelines.
-
-    Args:
-        t: A tensor (or non-tensor, which is returned as-is)
-
-    Returns:
-        The tensor, possibly cloned if it was received via IPC.
-    """
-    try:
-        import torch
-        if not isinstance(t, torch.Tensor):
-            return t
-
-        if not t.is_cuda:
-            # CPU tensors don't have this limitation
-            return t
-
-        # Test if tensor can be shared
-        import torch.multiprocessing.reductions as reductions
-        try:
-            func, args = reductions.reduce_tensor(t)
-            return t  # Can be shared as-is
-        except RuntimeError as e:
-            if "received from another process" in str(e):
-                # This tensor was received via IPC and can't be re-shared
-                tensor_size_mb = t.numel() * t.element_size() / (1024 * 1024)
-                if tensor_size_mb > 100:
-                    logger.warning(
-                        f"PERFORMANCE: Cloning large CUDA tensor ({tensor_size_mb:.1f}MB) "
-                        "received from another process. Consider modifying the node "
-                        "to avoid returning unmodified input tensors."
-                    )
-                else:
-                    logger.debug(
-                        f"Cloning CUDA tensor ({tensor_size_mb:.2f}MB) received from another process"
-                    )
-                return t.clone()
-            raise
-
-    except ImportError:
-        return t
-
-
-def prepare_for_ipc_recursive(obj: Any) -> Any:
-    """
-    Recursively prepare all tensors in a nested structure for IPC.
-
-    Also keeps tensor references to prevent GC.
-    """
-    try:
-        import torch
-        if isinstance(obj, torch.Tensor):
-            prepared = prepare_tensor_for_ipc(obj)
-            keep_tensor(prepared)
-            return prepared
-        elif isinstance(obj, list):
-            return [prepare_for_ipc_recursive(x) for x in obj]
-        elif isinstance(obj, tuple):
-            return tuple(prepare_for_ipc_recursive(x) for x in obj)
-        elif isinstance(obj, dict):
-            return {k: prepare_for_ipc_recursive(v) for k, v in obj.items()}
-    except ImportError:
-        pass
-    return obj

comfy_env-0.1.14.dist-info/METADATA

@@ -1,291 +0,0 @@
-Metadata-Version: 2.4
-Name: comfy-env
-Version: 0.1.14
-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; python_version < '3.11'
-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. Provides:
-
-1. **CUDA Wheel Resolution** - Install pre-built CUDA wheels (nvdiffrast, pytorch3d) without compilation
-2. **Process Isolation** - Run nodes in separate Python environments with their own dependencies
-
-## Why?
-
-ComfyUI custom nodes face two challenges:
-
-**Type 1: Dependency Conflicts**
-- Node A needs `torch==2.1.0` with CUDA 11.8
-- Node B needs `torch==2.8.0` with CUDA 12.8
-
-**Type 2: CUDA Package Installation**
-- Users don't have compilers installed
-- Building from source takes forever
-- pip install fails with cryptic errors
-
-This package solves both problems.
-
-## Installation
-
-```bash
-pip install comfy-env
-```
-
-Requires [uv](https://github.com/astral-sh/uv) for fast environment creation:
-
-```bash
-curl -LsSf https://astral.sh/uv/install.sh | sh
-```
-
-## Quick Start
-
-### In-Place Installation (Type 2 - CUDA Wheels)
-
-Create a `comfy-env.toml` in your node directory:
-
-```toml
-[cuda]
-packages = ["nvdiffrast", "pytorch3d"]
-
-[packages]
-requirements = ["transformers>=4.56", "pillow"]
-```
-
-Then in your `__init__.py`:
-
-```python
-from comfy_env import install
-
-# Install CUDA wheels into current environment
-install()
-```
-
-### Process Isolation (Type 1 - Separate Environment)
-
-For nodes that need completely separate dependencies (different Python version, conda packages, conflicting libraries).
-
-#### Recommended: Pack-Wide Isolation
-
-For node packs where ALL nodes run in the same isolated environment:
-
-**Step 1: Configure comfy-env.toml**
-
-```toml
-[mypack]
-python = "3.11"
-isolated = true          # All nodes run in this env
-
-[mypack.conda]
-packages = ["cgal"]      # Conda packages (uses pixi)
-
-[mypack.packages]
-requirements = ["trimesh[easy]>=4.0", "bpy>=4.2"]
-```
-
-**Step 2: Enable in __init__.py**
-
-```python
-from comfy_env import setup_isolated_imports, enable_isolation
-
-# Setup import stubs BEFORE importing nodes
-setup_isolated_imports(__file__)
-
-from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
-
-# Enable isolation for all nodes
-enable_isolation(NODE_CLASS_MAPPINGS)
-```
-
-**That's it!** All nodes run in an isolated Python 3.11 environment with their own dependencies.
-
-#### Alternative: Per-Node Isolation
-
-For cases where different nodes need different environments:
-
-```python
-from comfy_env import isolated
-
-@isolated(env="my-node")
-class MyNode:
-    FUNCTION = "process"
-    RETURN_TYPES = ("IMAGE",)
-
-    def process(self, image):
-        # Runs in isolated subprocess with its own venv
-        import conflicting_package
-        return (result,)
-```
-
-## CLI
-
-```bash
-# Show detected environment
-comfy-env info
-
-# Install from config
-comfy-env install
-
-# Dry run (show what would be installed)
-comfy-env install --dry-run
-
-# Verify installation
-comfy-env doctor
-```
-
-## Configuration
-
-### Simple Format (comfy-env.toml)
-
-```toml
-# CUDA packages from https://pozzettiandrea.github.io/cuda-wheels/
-[cuda]
-packages = ["nvdiffrast", "pytorch3d", "torch-scatter"]
-
-# Regular pip packages
-[packages]
-requirements = ["transformers>=4.56", "pillow"]
-```
-
-### Full Format
-
-```toml
-[system]
-linux = ["libgl1", "libopengl0"]  # apt packages
-
-[local.cuda]
-packages = ["nvdiffrast"]
-
-[local.packages]
-requirements = ["pillow", "numpy"]
-
-# For isolated environments (creates separate venv)
-[myenv]
-python = "3.10"
-cuda = "12.8"
-
-[myenv.cuda]
-packages = ["torch-scatter"]
-
-[myenv.packages]
-requirements = ["transformers>=4.56"]
-```
-
-## CUDA Wheels Index
-
-CUDA packages are installed from the [cuda-wheels](https://pozzettiandrea.github.io/cuda-wheels/) index, which provides pre-built wheels for:
-
-- **PyTorch Geometric**: torch-scatter, torch-cluster, torch-sparse, torch-spline-conv
-- **NVIDIA**: nvdiffrast, pytorch3d, gsplat
-- **Attention**: flash-attn, sageattention
-- **Mesh Processing**: cumesh, cubvh
-- **Others**: spconv, detectron2, lietorch, and more
-
-Wheels are automatically selected based on your GPU, CUDA version, PyTorch version, and Python version.
-
-### Supported Configurations
-
-| GPU Architecture | CUDA | PyTorch |
-|-----------------|------|---------|
-| Blackwell (sm_100+) | 12.8 | 2.8+ |
-| Ada/Hopper/Ampere (sm_80+) | 12.8 | 2.8 |
-| Turing (sm_75) | 12.8 | 2.8 |
-| Pascal (sm_60) | 12.4 | 2.4 |
-
-## API Reference
-
-### install()
-
-```python
-from comfy_env import install
-
-# Auto-discover config
-install()
-
-# Explicit config
-install(config="comfy-env.toml")
-
-# Dry run
-install(dry_run=True)
-```
-
-### RuntimeEnv
-
-```python
-from comfy_env import RuntimeEnv
-
-env = RuntimeEnv.detect()
-print(env)
-# Python 3.10, CUDA 12.8, PyTorch 2.8.0, GPU: NVIDIA GeForce RTX 4090
-
-# Get environment variables
-vars_dict = env.as_dict()
-# {'cuda_version': '12.8', 'cuda_short': '128', 'torch_mm': '28', ...}
-```
-
-### enable_isolation()
-
-```python
-from comfy_env import enable_isolation
-
-enable_isolation(NODE_CLASS_MAPPINGS)
-```
-
-Wraps all node classes so their FUNCTION methods run in the isolated environment specified in comfy-env.toml. Requires `isolated = true` in the environment config.
-
-### setup_isolated_imports()
-
-```python
-from comfy_env import setup_isolated_imports
-
-setup_isolated_imports(__file__)
-```
-
-Sets up import stubs for packages that exist only in the isolated pixi environment. Call this BEFORE importing your nodes module. Packages available in both host and isolated environment are not stubbed.
-
-### Workers (for custom isolation)
-
-```python
-from comfy_env import TorchMPWorker
-
-# Same-venv isolation (zero-copy tensors)
-worker = TorchMPWorker()
-result = worker.call(my_function, image=tensor)
-```
-
-## GPU Detection
-
-```python
-from comfy_env import detect_cuda_version, get_gpu_summary
-
-cuda = detect_cuda_version()  # "12.8", "12.4", or None
-print(get_gpu_summary())
-# GPU 0: NVIDIA GeForce RTX 5090 (sm_120) [Blackwell - CUDA 12.8]
-```
-
-## License
-
-MIT - see LICENSE file.

comfy_env-0.1.14.dist-info/RECORD

@@ -1,33 +0,0 @@
-comfy_env/__init__.py,sha256=xEbM77Oc7TKI-gu87_Lto8GF6Odjie-BKov4sr1XQ_k,2790
-comfy_env/cache.py,sha256=x705DNxvvY8GUQ40TLhIDk9vX3a7EFJOaskULybVWeM,9068
-comfy_env/cli.py,sha256=ty4HYlzollCUCS0o6Sha6eczPAsW_gHRVgvck3IfA2w,12723
-comfy_env/errors.py,sha256=q-C3vyrPa_kk_Ao8l17mIGfJiG2IR0hCFV0GFcNLmcI,9924
-comfy_env/install.py,sha256=N7eBj8wB2DrGepVYk-Hks2mSf6UuGzj34pfVLNYJgQ4,10357
-comfy_env/nodes.py,sha256=tUbsUdjnJCUUoxM7NpsdUuawuIz1exfOmWdsLGILXiY,5391
-comfy_env/prestartup.py,sha256=FjuQLfDs3ggc47siak33K4dhQzNRhCIEHshX7u1XQXc,6734
-comfy_env/config/__init__.py,sha256=4Guylkb-FV8QxhFwschzpzbr2eu8y-KNgNT3_JOm9jc,403
-comfy_env/config/parser.py,sha256=dA1lX5ExBEfCqUJwe4V5i_jn2NJ69bMq3c3ji3lMSV8,4295
-comfy_env/config/types.py,sha256=Sb8HO34xsSZu5YAc2K4M7Gb3QNevJlngf12hHiwuU0w,2140
-comfy_env/isolation/__init__.py,sha256=vw9a4mpJ2CFjy-PLe_A3zQ6umBQklgqWNxwn9beNw3g,175
-comfy_env/isolation/wrap.py,sha256=Z4JuQeLm4MIY9rzO7b2FJ5Q3p4onVswdklsYIYHAbwc,16182
-comfy_env/pixi/__init__.py,sha256=BUrq7AQf3WDm0cHWh72B2xZbURNnDu2dCuELWiQCUiM,997
-comfy_env/pixi/core.py,sha256=wXNy31deOI7QpRLPt9i1QfLrWGvKwg2j_kva-kaUEjs,21789
-comfy_env/pixi/cuda_detection.py,sha256=sqB3LjvGNdV4eFqiARQGfyecBM3ZiUmeh6nG0YCRYQw,9751
-comfy_env/pixi/resolver.py,sha256=U_A8rBDxCj4gUlJt2YJQniP4cCKqxJEiVFgXOoH7vM8,6339
-comfy_env/pixi/platform/__init__.py,sha256=Nb5MPZIEeanSMEWwqU4p4bnEKTJn1tWcwobnhq9x9IY,614
-comfy_env/pixi/platform/base.py,sha256=iS0ptTTVjXRwPU4qWUdvHI7jteuzxGSjWr5BUQ7hGiU,2453
-comfy_env/pixi/platform/darwin.py,sha256=HK3VkLT6DfesAnIXwx2IaUFHTBclF0xTQnC7azWY6Kc,1552
-comfy_env/pixi/platform/linux.py,sha256=xLp8FEbFqZLQrzIZBI9z3C4g23Ab1ASTHLsXDzsdCoA,2062
-comfy_env/pixi/platform/windows.py,sha256=FCOCgpzGzorY9-HueMlJUR8DxM2eH-cj9iZk6K026Is,10891
-comfy_env/templates/comfy-env-instructions.txt,sha256=ve1RAthW7ouumU9h6DM7mIRX1MS8_Tyonq2U4tcrFu8,1031
-comfy_env/templates/comfy-env.toml,sha256=ROIqi4BlPL1MEdL1VgebfTHpdwPNYGHwWeigI9Kw-1I,4831
-comfy_env/workers/__init__.py,sha256=TMVG55d2XLP1mJ3x1d16H0SBDJZtk2kMC5P4HLk9TrA,1073
-comfy_env/workers/base.py,sha256=4ZYTaQ4J0kBHCoO_OfZnsowm4rJCoqinZUaOtgkOPbw,2307
-comfy_env/workers/mp.py,sha256=R0XWsiHv8gswxa_-iNHU14o_9Og0RFG0QnY9DRZzn2c,34060
-comfy_env/workers/subprocess.py,sha256=B0PsHLuywPIJSRpuA4E8Dg6tGzuro6wqIr8czqMqtPE,57128
-comfy_env/workers/tensor_utils.py,sha256=TCuOAjJymrSbkgfyvcKtQ_KbVWTqSwP9VH_bCaFLLq8,6409
-comfy_env-0.1.14.dist-info/METADATA,sha256=o-SWEjHCqQWW2CcCWNGCbNcCtbYRAU70lAiNwXo41U8,6971
-comfy_env-0.1.14.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.1.14.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.1.14.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.1.14.dist-info/RECORD,,