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

comfy_env/isolation/__init__.py

@@ -2,8 +2,9 @@
 Isolation module for wrapping ComfyUI nodes to run in isolated environments.
 """
 
-from .wrap import wrap_isolated_nodes
+from .wrap import wrap_isolated_nodes, wrap_nodes
 
 __all__ = [
     "wrap_isolated_nodes",
+    "wrap_nodes",
 ]

comfy_env/isolation/wrap.py

@@ -174,12 +174,9 @@ def _find_env_paths(node_dir: Path) -> tuple[Optional[Path], Optional[Path]]:
     marker_path = node_dir / ".comfy-env-marker.toml"
     if marker_path.exists():
         try:
-            if sys.version_info >= (3, 11):
-                import tomllib
-            else:
-                import tomli as tomllib
+            import tomli
             with open(marker_path, "rb") as f:
-                marker = tomllib.load(f)
+                marker = tomli.load(f)
             env_path = marker.get("env", {}).get("path")
             if env_path:
                 env_dir = Path(env_path)
@@ -234,12 +231,9 @@ def _find_env_dir(node_dir: Path) -> Optional[Path]:
     marker_path = node_dir / ".comfy-env-marker.toml"
     if marker_path.exists():
         try:
-            if sys.version_info >= (3, 11):
-                import tomllib
-            else:
-                import tomli as tomllib
+            import tomli
             with open(marker_path, "rb") as f:
-                marker = tomllib.load(f)
+                marker = tomli.load(f)
             env_path = marker.get("env", {}).get("path")
             if env_path:
                 env_dir = Path(env_path)
@@ -391,6 +385,131 @@ def _wrap_node_class(
     return cls
 
 
+def _is_comfy_env_enabled() -> bool:
+    """Check if comfy-env isolation is enabled (default: True)."""
+    val = os.environ.get("USE_COMFY_ENV", "1").lower()
+    return val not in ("0", "false", "no", "off")
+
+
+def wrap_nodes() -> None:
+    """
+    Auto-wrap nodes for isolation. Call from your __init__.py after defining NODE_CLASS_MAPPINGS.
+
+    Usage:
+        from comfy_env import wrap_nodes
+        wrap_nodes()
+    """
+    # Skip if isolation is disabled
+    if not _is_comfy_env_enabled():
+        print(f"[comfy-env] Isolation disabled, nodes running in main process")
+        return
+
+    # Skip if running inside worker subprocess
+    if os.environ.get("COMFYUI_ISOLATION_WORKER") == "1":
+        return
+
+    # Get caller's frame and module
+    frame = inspect.stack()[1]
+    caller_module = inspect.getmodule(frame.frame)
+    if caller_module is None:
+        print("[comfy-env] Warning: Could not determine caller module")
+        return
+
+    # Get NODE_CLASS_MAPPINGS from caller's module
+    node_class_mappings = getattr(caller_module, "NODE_CLASS_MAPPINGS", None)
+    if not node_class_mappings:
+        print("[comfy-env] Warning: No NODE_CLASS_MAPPINGS found in caller module")
+        return
+
+    # Get package root directory
+    caller_file = Path(frame.filename).resolve()
+    package_dir = caller_file.parent
+
+    # Find all comfy-env.toml files
+    config_files = list(package_dir.rglob("comfy-env.toml"))
+    if not config_files:
+        return  # No configs, nothing to wrap
+
+    # Get ComfyUI base path
+    try:
+        import folder_paths
+        comfyui_base = folder_paths.base_path
+    except ImportError:
+        comfyui_base = None
+
+    # Build a map of config_dir -> env info
+    config_envs = []
+    for config_file in config_files:
+        config_dir = config_file.parent
+        env_dir = _find_env_dir(config_dir)
+        site_packages, lib_dir = _find_env_paths(config_dir)
+
+        if not env_dir or not site_packages:
+            continue
+
+        # Read env_vars from config
+        env_vars = {}
+        try:
+            import tomli
+            with open(config_file, "rb") as f:
+                config = tomli.load(f)
+            env_vars_data = config.get("env_vars", {})
+            env_vars = {str(k): str(v) for k, v in env_vars_data.items()}
+        except Exception:
+            pass
+
+        if comfyui_base:
+            env_vars["COMFYUI_BASE"] = str(comfyui_base)
+
+        config_envs.append({
+            "config_dir": config_dir,
+            "env_dir": env_dir,
+            "site_packages": site_packages,
+            "lib_dir": lib_dir,
+            "env_vars": env_vars,
+        })
+
+    if not config_envs:
+        return
+
+    # Match nodes to configs by checking source file location
+    wrapped_count = 0
+    for node_name, node_cls in node_class_mappings.items():
+        if not hasattr(node_cls, "FUNCTION"):
+            continue
+
+        # Get node's source file
+        try:
+            source_file = Path(inspect.getfile(node_cls)).resolve()
+        except (TypeError, OSError):
+            continue
+
+        # Find which config this node belongs to
+        for env_info in config_envs:
+            config_dir = env_info["config_dir"]
+            try:
+                source_file.relative_to(config_dir)
+                # Node is under this config dir - wrap it
+                sys_path = [str(env_info["site_packages"]), str(config_dir)]
+                lib_path = str(env_info["lib_dir"]) if env_info["lib_dir"] else None
+
+                _wrap_node_class(
+                    node_cls,
+                    env_info["env_dir"],
+                    config_dir,
+                    sys_path,
+                    lib_path,
+                    env_info["env_vars"],
+                )
+                wrapped_count += 1
+                break
+            except ValueError:
+                continue  # Node not under this config dir
+
+    if wrapped_count > 0:
+        print(f"[comfy-env] Wrapped {wrapped_count} nodes for isolation")
+
+
 def wrap_isolated_nodes(
     node_class_mappings: Dict[str, type],
     nodes_dir: Path,
@@ -425,6 +544,11 @@ def wrap_isolated_nodes(
             wrap_isolated_nodes(cgal_nodes, Path(__file__).parent / "nodes/cgal")
         )
     """
+    # Skip if isolation is disabled
+    if not _is_comfy_env_enabled():
+        print(f"[comfy-env] Isolation disabled, nodes running in main process")
+        return node_class_mappings
+
     # Skip if running inside worker subprocess
     if os.environ.get("COMFYUI_ISOLATION_WORKER") == "1":
         return node_class_mappings
@@ -447,12 +571,9 @@ def wrap_isolated_nodes(
     # Read env_vars from comfy-env.toml
     env_vars = {}
     try:
-        if sys.version_info >= (3, 11):
-            import tomllib
-        else:
-            import tomli as tomllib
+        import tomli
         with open(config_file, "rb") as f:
-            config = tomllib.load(f)
+            config = tomli.load(f)
         env_vars_data = config.get("env_vars", {})
         env_vars = {str(k): str(v) for k, v in env_vars_data.items()}
     except Exception:

comfy_env/nodes.py

@@ -17,7 +17,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Callable, List, Set
 
 if TYPE_CHECKING:
-    from .config.types import NodeReq
+    from .config.parser import NodeReq
 
 
 def normalize_repo_url(repo: str) -> str:

comfy_env/pixi/core.py

@@ -18,7 +18,7 @@ import urllib.request
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
-from ..config.types import ComfyEnvConfig
+from ..config.parser import ComfyEnvConfig
 
 
 # Pixi download URLs by platform
@@ -37,7 +37,6 @@ CUDA_WHEELS_INDEX = "https://pozzettiandrea.github.io/cuda-wheels/"
 CUDA_TORCH_MAP = {
     "12.8": "2.8",
     "12.4": "2.4",
-    "12.1": "2.4",
 }
 
 def find_wheel_url(

comfy_env/prestartup.py

@@ -20,24 +20,16 @@ def get_env_name(dir_name: str) -> str:
 def _load_env_vars(config_path: str) -> Dict[str, str]:
     """
     Load [env_vars] section from comfy-env.toml.
-
-    Uses tomllib (Python 3.11+) or tomli fallback.
     Returns empty dict if file not found or parsing fails.
     """
     if not os.path.exists(config_path):
         return {}
 
     try:
-        if sys.version_info >= (3, 11):
-            import tomllib
-        else:
-            try:
-                import tomli as tomllib
-            except ImportError:
-                return {}
+        import tomli
 
         with open(config_path, "rb") as f:
-            data = tomllib.load(f)
+            data = tomli.load(f)
 
         env_vars_data = data.get("env_vars", {})
         return {str(k): str(v) for k, v in env_vars_data.items()}
@@ -95,6 +87,12 @@ def _dedupe_libomp_macos():
                 pass  # Permission denied, etc.
 
 
+def _is_comfy_env_enabled() -> bool:
+    """Check if comfy-env isolation is enabled (default: True)."""
+    val = os.environ.get("USE_COMFY_ENV", "1").lower()
+    return val not in ("0", "false", "no", "off")
+
+
 def setup_env(node_dir: Optional[str] = None) -> None:
     """
     Set up environment for pixi conda libraries.
@@ -112,6 +110,10 @@ def setup_env(node_dir: Optional[str] = None) -> None:
         from comfy_env import setup_env
         setup_env()
     """
+    # Skip if isolation is disabled
+    if not _is_comfy_env_enabled():
+        return
+
     # macOS: Dedupe libomp to prevent OpenMP conflicts (torch vs pymeshlab, etc.)
     _dedupe_libomp_macos()
 
@@ -137,12 +139,9 @@ def setup_env(node_dir: Optional[str] = None) -> None:
     marker_path = os.path.join(node_dir, ".comfy-env-marker.toml")
     if os.path.exists(marker_path):
         try:
-            if sys.version_info >= (3, 11):
-                import tomllib
-            else:
-                import tomli as tomllib
+            import tomli
             with open(marker_path, "rb") as f:
-                marker = tomllib.load(f)
+                marker = tomli.load(f)
             env_path = marker.get("env", {}).get("path")
             if env_path and os.path.exists(env_path):
                 pixi_env = env_path
@@ -190,3 +189,20 @@ def setup_env(node_dir: Optional[str] = None) -> None:
 
     if site_packages and os.path.exists(site_packages) and site_packages not in sys.path:
         sys.path.insert(0, site_packages)
+
+
+def copy_files(src, dst, pattern: str = "*") -> None:
+    """Copy files matching pattern from src to dst (skip existing)."""
+    import shutil
+
+    src, dst = Path(src), Path(dst)
+    if not src.exists():
+        return
+
+    dst.mkdir(parents=True, exist_ok=True)
+    for f in src.glob(pattern):
+        if f.is_file():
+            target = dst / f.relative_to(src)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            if not target.exists():
+                shutil.copy2(f, target)

comfy_env/workers/subprocess.py

@@ -440,7 +440,7 @@ def _watchdog():
             f.flush()
 
         # Also print
-        print(f"\\n=== WATCHDOG TICK {tick} ===", flush=True)
+        print(f"\\n=== WATCHDOG TICK {tick} (debug only, don't worry) ===", flush=True)
         print(dump, flush=True)
         print("=== END ===\\n", flush=True)
 

{comfy_env-0.1.14.dist-info → comfy_env-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.1.14
+Version: 0.1.15
 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
@@ -19,7 +19,7 @@ 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: tomli>=2.0.0
 Requires-Dist: uv>=0.4.0
 Provides-Extra: dev
 Requires-Dist: mypy; extra == 'dev'

comfy_env-0.1.15.dist-info/RECORD

@@ -0,0 +1,31 @@
+comfy_env/__init__.py,sha256=vtMEMhys8esoSXM3H5pFJGecE_ZoDwPS0foeEzlbmZA,2331
+comfy_env/cache.py,sha256=LnOVGCheF0hM-JZcX_-HD46o_nA7U2SIptdOT1TQkBE,6293
+comfy_env/cli.py,sha256=UJbPbCEKfAAoZ_J0JeUs4jVsWuJ8BeR6CV6XtCSuy1g,12707
+comfy_env/install.py,sha256=nuG3z5V1PQ4IoXKknLfS9sUKAUq0RHcpZp7jvdOTgIY,14853
+comfy_env/nodes.py,sha256=tqMBf3hTjtgbT9sdcUiNnMaiFNPsHWtw79_TgvsrU9Q,5392
+comfy_env/prestartup.py,sha256=Aw8yvmkraP3bRXPTZKOFnhUHLNtGujAZ4aD76nKx6pA,7215
+comfy_env/config/__init__.py,sha256=_udIO2AkntkFfktst1uKqRkLdne1cXf2b0BrErvNT_k,289
+comfy_env/config/parser.py,sha256=B9iK3RQdErAHnmvD_jfZm87u5K5gTnEwFDMdOXil3YM,3458
+comfy_env/isolation/__init__.py,sha256=Fy8A7_5plxcCMFOf00cJlEMbRVu8aKFkTo0Spj31YqI,206
+comfy_env/isolation/wrap.py,sha256=vJz75TtS6NMyfxX_UlqNdZNQQYROHP9KbcghmNIPyFM,20046
+comfy_env/pixi/__init__.py,sha256=BUrq7AQf3WDm0cHWh72B2xZbURNnDu2dCuELWiQCUiM,997
+comfy_env/pixi/core.py,sha256=LY2wrvMNqO-cp9MOgixvpe1mJKtGK3U311-0rbURTBo,21770
+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=FvhEWilFWkjYNVDm7mmbFmXiSYB7eT5Tl2uvJ_23qnc,57154
+comfy_env/workers/tensor_utils.py,sha256=TCuOAjJymrSbkgfyvcKtQ_KbVWTqSwP9VH_bCaFLLq8,6409
+comfy_env-0.1.15.dist-info/METADATA,sha256=HMJQ4qs9ObD6YpTGffqmUACR67_kzcWv392WpdNASzc,6946
+comfy_env-0.1.15.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.1.15.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.1.15.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.1.15.dist-info/RECORD,,

comfy_env/config/types.py

@@ -1,70 +0,0 @@
-"""Configuration types for comfy-env."""
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
-
-
-@dataclass
-class NodeReq:
-    """A node dependency (another ComfyUI custom node)."""
-    name: str
-    repo: str  # GitHub repo, e.g., "owner/repo"
-
-
-@dataclass
-class ComfyEnvConfig:
-    """
-    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:
-    - [dependencies] - conda packages
-    - [pypi-dependencies] - pip packages
-    - [target.linux-64.pypi-dependencies] - platform-specific deps
-    - Any other pixi.toml syntax
-
-    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 = "*"
-
-        [node_reqs]
-        SomeNode = "owner/repo"
-    """
-    # python = "3.11" - Python version (for isolated envs)
-    python: Optional[str] = None
-
-    # [cuda] - CUDA packages (installed via find-links index)
-    cuda_packages: List[str] = field(default_factory=list)
-
-    # [apt] - System packages to install via apt (Linux only)
-    apt_packages: List[str] = field(default_factory=list)
-
-    # [env_vars] - Environment variables to set early (in prestartup)
-    env_vars: Dict[str, str] = field(default_factory=dict)
-
-    # [node_reqs] - other ComfyUI nodes to clone
-    node_reqs: List[NodeReq] = field(default_factory=list)
-
-    # Everything else from comfy-env.toml passes through to pixi.toml
-    pixi_passthrough: Dict[str, Any] = field(default_factory=dict)
-
-    @property
-    def has_cuda(self) -> bool:
-        return bool(self.cuda_packages)