comfy-env 0.0.65__py3-none-any.whl → 0.0.67__py3-none-any.whl

comfy_env/templates/comfy-env.toml

@@ -1,82 +1,85 @@
 # =============================================================================
 # comfy-env.toml - Environment configuration for ComfyUI custom nodes
-# Documentation: https://github.com/PozzettiAndrea/comfy-env
 # =============================================================================
 #
-# This file configures dependencies for your ComfyUI custom node.
-# comfy-env handles two main challenges:
-#   1. Installing CUDA packages that require compilation (nvdiffrast, pytorch3d, etc.)
-#   2. Running nodes in isolated environments with their own dependencies
+# comfy-env.toml is a SUPERSET of pixi.toml. All pixi.toml syntax works here.
+# We add custom sections: [cuda], [node_reqs], and top-level `python = "x.x"`.
+#
+# GPU is auto-detected to select the right CUDA version.
 #
 # Quick start:
 #   pip install comfy-env
 #   comfy-env init          # Creates this template
 #   comfy-env install       # Installs dependencies
-#   comfy-env doctor        # Verifies installation
 
 
 # =============================================================================
-# SYSTEM PACKAGES (optional)
+# PYTHON VERSION (optional)
 # =============================================================================
-# System-level packages installed via apt (Linux) before Python packages.
-# Useful for packages that need system libraries to compile or run.
+# Specify Python version for isolated environments (e.g., bpy needs Python 3.11)
+# Omit this to use the host Python version.
 
-[system]
-linux = []
-# Examples:
-# linux = ["libgl1", "libopengl0"]     # For OpenGL rendering (nvdiffrast)
-# linux = ["python3-dev"]               # For packages that compile C extensions
-# linux = ["ffmpeg"]                    # For video processing nodes
+# python = "3.11"
 
 
 # =============================================================================
-# CUDA PACKAGES
+# CUDA PACKAGES (custom section)
 # =============================================================================
-# CUDA packages from the built-in registry. These are pre-compiled wheels
-# that install without needing a compiler. Run `comfy-env list-packages`
-# to see all available packages.
+# Pre-compiled CUDA wheels from the cuda-wheels index.
+# Pixi auto-selects the right wheel based on your GPU.
+# Supports CUDA 12.8 → PyTorch 2.8 or CUDA 12.4 → PyTorch 2.4
 
 [cuda]
-# Use exact package names from `comfy-env list-packages` (hyphens vs underscores matter!)
-# nvdiffrast = "0.4.0"       # NVIDIA differentiable rasterizer
-# pytorch3d = "0.7.9"        # PyTorch3D - 3D deep learning
-# gsplat = "1.5.3"           # Gaussian splatting rasterization
-# torch-scatter = "2.1.2"    # PyG scatter operations
-# torch-cluster = "1.6.3"    # PyG clustering algorithms
-# flash-attn = "2.7.4"       # Flash Attention (Linux x86_64 only)
-# spconv = "2.3.8"           # Sparse convolution library
-# sageattention = "2.2.0"    # SageAttention - faster than FlashAttention
-# dpvo_cuda = "0.0.0"        # DPVO CUDA extensions
+packages = []
+# Examples:
+# packages = [
+#     "nvdiffrast",        # NVIDIA differentiable rasterizer
+#     "pytorch3d",         # PyTorch3D - 3D deep learning
+#     "gsplat",            # Gaussian splatting
+#     "cumesh",            # GPU mesh processing
+#     "flash-attn",        # Flash Attention (Linux only)
+# ]
 
 
 # =============================================================================
-# REGULAR PACKAGES
+# CONDA PACKAGES (pixi-native)
 # =============================================================================
-# Standard pip packages (no special CUDA handling needed).
+# Conda packages from conda-forge (includes system libraries).
+# Use this instead of apt/brew - works cross-platform.
 
-[packages]
-requirements = []
-# Examples:
-# requirements = [
-#     "transformers>=4.56",
-#     "pillow",
-#     "opencv-python-headless",
-#     "trimesh",
-# ]
+[dependencies]
+# mesalib = "*"           # OpenGL (replaces libgl1)
+# libglu = "*"            # GLU library
+# ffmpeg = "*"            # Video processing
+# cgal = "*"              # Computational geometry
+
+
+# =============================================================================
+# PIP PACKAGES (pixi-native)
+# =============================================================================
+# Regular pip packages.
+
+[pypi-dependencies]
+# numpy = ">=1.21.0,<2"
+# trimesh = { version = ">=4.0.0", extras = ["easy"] }
+# pillow = "*"
 
 
 # =============================================================================
-# CUSTOM WHEEL SOURCES (optional)
+# PLATFORM-SPECIFIC PACKAGES (pixi-native)
 # =============================================================================
-# Override built-in wheel URLs or add packages not in the registry.
-# Template variables: {version}, {cuda_short}, {torch_mm}, {py_tag}, {platform}
+# Use pixi's target syntax for platform-specific packages.
+
+# [target.linux-64.pypi-dependencies]
+# embreex = "*"
 
-[wheel_sources]
-# my-custom-package = "https://my-server.com/my-package-{version}+cu{cuda_short}-{py_tag}-{platform}.whl"
+# [target.win-64.pypi-dependencies]
+# msvc-runtime = "*"
+# embreex = "*"
 
 
 # =============================================================================
-# NODE DEPENDENCIES (optional)
+# NODE DEPENDENCIES (custom section)
 # =============================================================================
 # Other ComfyUI custom nodes this node depends on.
 
@@ -85,93 +88,31 @@ requirements = []
 # ComfyUI-Impact-Pack = "ltdrdata/ComfyUI-Impact-Pack"
 
 
-# #############################################################################
-#
-#                       PROCESS ISOLATION (ADVANCED)
-#
-# #############################################################################
-#
-# For nodes that need completely isolated dependencies (different Python
-# version, conda packages, conflicting native libraries), define an isolated
-# environment with `isolated = true`.
-#
-# RECOMMENDED: Pack-wide isolation (all nodes in one environment)
-# ----------------------------------------------------------------
-# This is the simplest approach - all your nodes run in the same isolated env.
-#
-# Step 1: Define environment in comfy-env.toml (this file)
-# Step 2: In __init__.py:
-#
-#     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)
-#
 # =============================================================================
-
-
-# -----------------------------------------------------------------------------
-# Example: Full pack isolation with conda packages (RECOMMENDED)
-# -----------------------------------------------------------------------------
-# Uses pixi to create an isolated environment with conda + pip packages.
-
-# [mypack]
-# python = "3.11"
-# isolated = true           # Required for enable_isolation()
-#
-# [mypack.conda]
-# channels = ["conda-forge"]
-# packages = ["cgal", "openmesh"]
-#
-# [mypack.packages]
-# requirements = ["trimesh[easy]>=4.0", "numpy", "scipy"]
-
-
-# -----------------------------------------------------------------------------
-# Example: Multiple isolated environments (per-node control)
-# -----------------------------------------------------------------------------
-# Use @isolated(env="envname") decorator when different nodes need different envs.
-#
-#     from comfy_env import isolated
+# PROCESS ISOLATION
+# =============================================================================
 #
-#     @isolated(env="env-preprocessing")
-#     class PreprocessNode: ...
+# For nodes needing isolated environments, put comfy-env.toml in a subdirectory:
 #
-#     @isolated(env="env-inference")
-#     class InferenceNode: ...
-
-# [env-preprocessing]
-# python = "3.11"
+#   ComfyUI-MyPack/
+#   ├── comfy-env.toml       # Root: installs to main env
+#   ├── __init__.py
+#   └── nodes/
+#       └── isolated/
+#           ├── comfy-env.toml   # Subdirectory: isolated env
+#           └── *.py
 #
-# [env-preprocessing.packages]
-# requirements = ["opencv-python-headless", "pillow"]
-
-# [env-inference]
-# python = "3.10"
+# In your nodes/__init__.py:
 #
-# [env-inference.cuda]
-# torch-scatter = "2.1.2"
-
-
-# -----------------------------------------------------------------------------
-# Example: Platform-specific packages
-# -----------------------------------------------------------------------------
-# Different packages for Windows vs Linux.
-
-# [crossplatform]
-# python = "3.11"
-# isolated = true
+#   from pathlib import Path
+#   from comfy_env import wrap_isolated_nodes
 #
-# [crossplatform.packages]
-# requirements = ["numpy", "pillow"]
+#   NODE_CLASS_MAPPINGS = {}
 #
-# [crossplatform.packages.windows]
-# requirements = ["pywin32"]
+#   from .main import NODE_CLASS_MAPPINGS as main_nodes
+#   NODE_CLASS_MAPPINGS.update(main_nodes)
 #
-# [crossplatform.packages.linux]
-# requirements = ["python-xlib"]
+#   from .isolated import NODE_CLASS_MAPPINGS as isolated_nodes
+#   NODE_CLASS_MAPPINGS.update(
+#       wrap_isolated_nodes(isolated_nodes, Path(__file__).parent / "isolated")
+#   )

comfy_env/workers/__init__.py

@@ -1,49 +1,38 @@
 """
-Workers - Simple, explicit process isolation for ComfyUI nodes.
+Workers - Process isolation for ComfyUI nodes.
 
-This module provides three isolation tiers:
+This module provides two isolation tiers:
 
-Tier 1: TorchMPWorker (same Python, fresh CUDA context)
-    - Uses torch.multiprocessing.Queue
-    - Zero-copy tensor transfer via CUDA IPC
+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: VenvWorker (different Python/venv)
-    - Uses subprocess + torch.save/load via /dev/shm
-    - One memcpy per tensor direction
-    - ~100-500ms overhead per call
+Tier 2: SubprocessWorker (different Python/venv)
+    - Persistent subprocess + socket IPC
+    - ~50-100ms overhead per call
     - Use for: Different PyTorch versions, incompatible deps
 
-Tier 3: ContainerWorker (full isolation) [future]
-    - Docker with GPU passthrough
-    - Use for: Different CUDA versions, hermetic environments
-
 Usage:
-    from comfy_env.workers import get_worker, TorchMPWorker
-
-    # Get a named worker from the pool
-    worker = get_worker("sam3d")
-    result = worker.call(my_function, image=tensor)
+    from comfy_env.workers import MPWorker, SubprocessWorker
 
-    # Or create directly
-    worker = TorchMPWorker()
+    # 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
-from .torch_mp import TorchMPWorker
-from .venv import VenvWorker, PersistentVenvWorker
-from .pool import WorkerPool, get_worker, register_worker, shutdown_workers, list_workers
+from .base import Worker, WorkerError
+from .mp import MPWorker
+from .subprocess import SubprocessWorker
 
 __all__ = [
     "Worker",
-    "TorchMPWorker",
-    "VenvWorker",
-    "PersistentVenvWorker",
-    "WorkerPool",
-    "get_worker",
-    "register_worker",
-    "shutdown_workers",
-    "list_workers",
+    "WorkerError",
+    "MPWorker",
+    "SubprocessWorker",
 ]

comfy_env/workers/base.py

@@ -16,7 +16,7 @@ class Worker(ABC):
 
     Workers should be used as context managers when possible:
 
-        with TorchMPWorker() as worker:
+        with MPWorker() as worker:
             result = worker.call(my_func, arg1, arg2)
     """
 

comfy_env/workers/{torch_mp.py → mp.py}

@@ -1,9 +1,9 @@
 """
-TorchMPWorker - Same-venv isolation using torch.multiprocessing.
+MPWorker - Same-venv isolation using multiprocessing.
 
 This is the simplest and fastest worker type:
-- Uses torch.multiprocessing.Queue for IPC
-- Zero-copy tensor transfer via CUDA IPC (automatic)
+- Uses multiprocessing.Queue for IPC
+- Zero-copy tensor transfer via shared memory (automatic)
 - Fresh CUDA context in subprocess
 - ~30ms overhead per call
 
@@ -13,7 +13,7 @@ Use this when you need:
 - Same Python environment as host
 
 Example:
-    worker = TorchMPWorker()
+    worker = MPWorker()
 
     def gpu_work(image):
         import torch
@@ -40,7 +40,7 @@ _SHUTDOWN = object()
 _CALL_METHOD = "call_method"
 
 
-def _worker_loop(queue_in, queue_out, sys_path_additions=None):
+def _worker_loop(queue_in, queue_out, sys_path_additions=None, lib_path=None):
     """
     Worker process main loop.
 
@@ -55,6 +55,7 @@ def _worker_loop(queue_in, queue_out, sys_path_additions=None):
         queue_in: Input queue for receiving work items
         queue_out: Output queue for sending results
         sys_path_additions: Paths to add to sys.path
+        lib_path: Path to add to LD_LIBRARY_PATH (for conda libraries)
     """
     import os
     import sys
@@ -63,10 +64,40 @@ def _worker_loop(queue_in, queue_out, sys_path_additions=None):
     # Set worker mode env var
     os.environ["COMFYUI_ISOLATION_WORKER"] = "1"
 
-    # Add stubs directory for folder_paths etc. (same as PersistentVenvWorker)
-    stubs_dir = Path(__file__).parent.parent / "stubs"
-    if str(stubs_dir) not in sys.path:
-        sys.path.insert(0, str(stubs_dir))
+    # Set LD_LIBRARY_PATH for conda libraries (must be done before imports)
+    if lib_path:
+        if sys.platform == "win32":
+            # Windows: add to PATH for DLL loading
+            os.environ["PATH"] = lib_path + ";" + os.environ.get("PATH", "")
+        else:
+            # Linux/Mac: LD_LIBRARY_PATH
+            os.environ["LD_LIBRARY_PATH"] = lib_path + ":" + os.environ.get("LD_LIBRARY_PATH", "")
+
+    # Find ComfyUI base and add to sys.path for real folder_paths/comfy modules
+    # This works because comfy.options.args_parsing=False by default, so folder_paths
+    # auto-detects its base directory from __file__ location
+    def _find_comfyui_base():
+        cwd = Path.cwd().resolve()
+        # Check common child directories (for test environments)
+        for base in [cwd, cwd.parent]:
+            for child in [".comfy-test-env/ComfyUI", "ComfyUI"]:
+                candidate = base / child
+                if (candidate / "main.py").exists() and (candidate / "comfy").exists():
+                    return candidate
+        # Walk up from cwd looking for ComfyUI
+        current = cwd
+        for _ in range(10):
+            if (current / "main.py").exists() and (current / "comfy").exists():
+                return current
+            current = current.parent
+        # Check COMFYUI_BASE env var as fallback
+        if os.environ.get("COMFYUI_BASE"):
+            return Path(os.environ["COMFYUI_BASE"])
+        return None
+
+    comfyui_base = _find_comfyui_base()
+    if comfyui_base and str(comfyui_base) not in sys.path:
+        sys.path.insert(0, str(comfyui_base))
 
     # Add custom paths to sys.path for module discovery
     if sys_path_additions:
@@ -356,7 +387,7 @@ def _execute_method_call(module_name: str, class_name: str, method_name: str,
     return original_method(instance, **kwargs)
 
 
-class TorchMPWorker(Worker):
+class MPWorker(Worker):
     """
     Worker using torch.multiprocessing for same-venv isolation.
 
@@ -370,16 +401,18 @@ class TorchMPWorker(Worker):
     interpreter without inherited state from the parent.
     """
 
-    def __init__(self, name: Optional[str] = None, sys_path: Optional[list] = None):
+    def __init__(self, name: Optional[str] = None, sys_path: Optional[list] = None, lib_path: Optional[str] = None):
         """
         Initialize the worker.
 
         Args:
             name: Optional name for logging/debugging.
             sys_path: Optional list of paths to add to sys.path in worker process.
+            lib_path: Optional path to add to LD_LIBRARY_PATH (for conda libraries).
         """
-        self.name = name or "TorchMPWorker"
+        self.name = name or "MPWorker"
         self._sys_path = sys_path or []
+        self._lib_path = lib_path
         self._process = None
         self._queue_in = None
         self._queue_out = None
@@ -406,7 +439,7 @@ class TorchMPWorker(Worker):
         self._queue_out = ctx.Queue()
         self._process = ctx.Process(
             target=_worker_loop,
-            args=(self._queue_in, self._queue_out, self._sys_path),
+            args=(self._queue_in, self._queue_out, self._sys_path, self._lib_path),
             daemon=True,
         )
         self._process.start()
@@ -593,4 +626,4 @@ class TorchMPWorker(Worker):
 
     def __repr__(self):
         status = "alive" if self.is_alive() else "stopped"
-        return f"<TorchMPWorker name={self.name!r} status={status}>"
+        return f"<MPWorker name={self.name!r} status={status}>"