comfy-env 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

comfy_env/isolation/wrap.py

@@ -211,6 +211,34 @@ def _find_env_dir(node_dir: Path) -> Optional[Path]:
     return None
 
 
+def _find_custom_node_root(nodes_dir: Path) -> Optional[Path]:
+    """
+    Find the custom node root (direct child of custom_nodes/).
+
+    Uses folder_paths to find custom_nodes directories, then finds
+    which one is an ancestor of nodes_dir.
+
+    Example: /path/custom_nodes/ComfyUI-UniRig/nodes/nodes_gpu
+             -> returns /path/custom_nodes/ComfyUI-UniRig
+    """
+    try:
+        import folder_paths
+        custom_nodes_dirs = folder_paths.get_folder_paths("custom_nodes")
+    except (ImportError, KeyError):
+        return None
+
+    for cn_dir in custom_nodes_dirs:
+        cn_path = Path(cn_dir)
+        try:
+            rel = nodes_dir.relative_to(cn_path)
+            if rel.parts:
+                return cn_path / rel.parts[0]
+        except ValueError:
+            continue
+
+    return None
+
+
 def _wrap_node_class(
     cls: type,
     env_dir: Path,
@@ -388,7 +416,9 @@ def wrap_isolated_nodes(
         print(f"[comfy-env] Run 'comfy-env install' in {nodes_dir}")
         return node_class_mappings
 
-    # Build sys.path for the worker - site-packages first, then node dir
+    # Build sys.path - site-packages first, then nodes_dir
+    # Note: isolated modules should use absolute imports (their dir is in sys.path)
+    # Relative imports would require importing parent package which may have host-only deps
     sys_path = [str(site_packages), str(nodes_dir)]
 
     # lib_dir for LD_LIBRARY_PATH (conda libraries)

comfy_env/nodes.py

@@ -10,6 +10,7 @@ Example configuration:
     ComfyUI-DepthAnythingV2 = "kijai/ComfyUI-DepthAnythingV2"
 """
 
+import shutil
 import subprocess
 import sys
 from pathlib import Path
@@ -84,16 +85,20 @@ def install_requirements(
     """
     requirements_file = node_dir / "requirements.txt"
 
-    if requirements_file.exists():
-        log(f"  Installing requirements for {node_dir.name}...")
-        result = subprocess.run(
-            ["uv", "pip", "install", "-r", str(requirements_file), "--python", sys.executable],
-            cwd=node_dir,
-            capture_output=True,
-            text=True,
-        )
-        if result.returncode != 0:
-            log(f"  Warning: requirements.txt install failed for {node_dir.name}: {result.stderr.strip()[:200]}")
+    if not requirements_file.exists():
+        return
+
+    log(f"  Installing requirements for {node_dir.name}...")
+
+    # Try uv first, fall back to pip if uv not in PATH
+    if shutil.which("uv"):
+        cmd = ["uv", "pip", "install", "-r", str(requirements_file), "--python", sys.executable]
+    else:
+        cmd = [sys.executable, "-m", "pip", "install", "-r", str(requirements_file)]
+
+    result = subprocess.run(cmd, cwd=node_dir, capture_output=True, text=True)
+    if result.returncode != 0:
+        log(f"  Warning: requirements.txt install failed for {node_dir.name}: {result.stderr.strip()[:200]}")
 
 
 def run_install_script(

comfy_env/pixi/core.py

@@ -457,11 +457,14 @@ def pixi_install(
     # Build pypi-dependencies section (CUDA packages excluded - installed separately)
     pypi_deps = pixi_data.get("pypi-dependencies", {})
 
-    # Add torch if we have CUDA packages
+    # Enforce torch version if we have CUDA packages (must match cuda_packages wheels)
     if cfg.has_cuda and torch_version:
         torch_major = torch_version.split(".")[0]
         torch_minor = int(torch_version.split(".")[1])
-        pypi_deps.setdefault("torch", f">={torch_version},<{torch_major}.{torch_minor + 1}")
+        required_torch = f">={torch_version},<{torch_major}.{torch_minor + 1}"
+        if "torch" in pypi_deps and pypi_deps["torch"] != required_torch:
+            log(f"Overriding torch={pypi_deps['torch']} with {required_torch} (required for cuda_packages)")
+        pypi_deps["torch"] = required_torch
 
     # NOTE: CUDA packages are NOT added here - they're installed with --no-deps after pixi
 
@@ -494,8 +497,16 @@ def pixi_install(
         if not python_path:
             raise RuntimeError("Could not find Python in pixi environment")
 
-        # Get Python version from the pixi environment
-        py_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+        # Get Python version from the pixi environment (not host Python)
+        result = subprocess.run(
+            [str(python_path), "-c", "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"],
+            capture_output=True, text=True
+        )
+        if result.returncode == 0:
+            py_version = result.stdout.strip()
+        else:
+            py_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+            log(f"Warning: Could not detect pixi Python version, using host: {py_version}")
 
         for package in cfg.cuda_packages:
             # Find direct wheel URL (bypasses metadata validation)

comfy_env/workers/subprocess.py

@@ -228,23 +228,19 @@ def _to_shm(obj, registry, visited=None):
         result["__was_tensor__"] = True
         return result
 
-    # trimesh.Trimesh → vertices + faces arrays → shared memory
+    # trimesh.Trimesh → pickle → shared memory (preserves visual, metadata, normals)
     if t == 'Trimesh':
-        verts = np.ascontiguousarray(obj.vertices, dtype=np.float64)
-        faces = np.ascontiguousarray(obj.faces, dtype=np.int64)
+        import pickle
+        mesh_bytes = pickle.dumps(obj)
 
-        v_block = shm.SharedMemory(create=True, size=verts.nbytes)
-        np.ndarray(verts.shape, verts.dtype, buffer=v_block.buf)[:] = verts
-        registry.append(v_block)
-
-        f_block = shm.SharedMemory(create=True, size=faces.nbytes)
-        np.ndarray(faces.shape, faces.dtype, buffer=f_block.buf)[:] = faces
-        registry.append(f_block)
+        block = shm.SharedMemory(create=True, size=len(mesh_bytes))
+        block.buf[:len(mesh_bytes)] = mesh_bytes
+        registry.append(block)
 
         result = {
             "__shm_trimesh__": True,
-            "v_name": v_block.name, "v_shape": list(verts.shape),
-            "f_name": f_block.name, "f_shape": list(faces.shape),
+            "name": block.name,
+            "size": len(mesh_bytes),
         }
         visited[obj_id] = result
         return result
@@ -294,22 +290,15 @@ def _from_shm(obj, unlink=True):
             return torch.from_numpy(arr)
         return arr
 
-    # trimesh
+    # trimesh (pickled to preserve visual, metadata, normals)
     if "__shm_trimesh__" in obj:
-        import trimesh
-        v_block = shm.SharedMemory(name=obj["v_name"])
-        verts = np.ndarray(tuple(obj["v_shape"]), dtype=np.float64, buffer=v_block.buf).copy()
-        v_block.close()
-        if unlink:
-            v_block.unlink()
-
-        f_block = shm.SharedMemory(name=obj["f_name"])
-        faces = np.ndarray(tuple(obj["f_shape"]), dtype=np.int64, buffer=f_block.buf).copy()
-        f_block.close()
+        import pickle
+        block = shm.SharedMemory(name=obj["name"])
+        mesh_bytes = bytes(block.buf[:obj["size"]])
+        block.close()
         if unlink:
-            f_block.unlink()
-
-        return trimesh.Trimesh(vertices=verts, faces=faces, process=False)
+            block.unlink()
+        return pickle.loads(mesh_bytes)
 
     # regular dict - recurse
     return {k: _from_shm(v, unlink) for k, v in obj.items()}
@@ -426,42 +415,29 @@ faulthandler.enable(file=sys.stderr, all_threads=True)
 # Debug logging (set COMFY_ENV_DEBUG=1 to enable)
 _DEBUG = os.environ.get("COMFY_ENV_DEBUG", "").lower() in ("1", "true", "yes")
 
-# Pre-import bpy FIRST to avoid DLL conflicts with numpy/torch/MKL
-# bpy's DLLs must be loaded before other packages load conflicting versions
-try:
-    import bpy
-    if _DEBUG:
-        print("[worker] Pre-imported bpy successfully", file=sys.stderr, flush=True)
-except ImportError as e:
-    # bpy not available in this environment - that's fine
-    pass
-except Exception as e:
-    if _DEBUG:
-        print(f"[worker] bpy pre-import warning: {e}", file=sys.stderr, flush=True)
-
 # Watchdog: dump all thread stacks every 60 seconds to catch hangs
 import threading
 import tempfile as _tempfile
 _watchdog_log = os.path.join(_tempfile.gettempdir(), "comfy_worker_watchdog.log")
 def _watchdog():
     import time
-    import io
     tick = 0
     while True:
         time.sleep(60)
         tick += 1
-        # Capture stack dump to string
-        buf = io.StringIO()
-        faulthandler.dump_traceback(file=buf, all_threads=True)
-        dump = buf.getvalue()
-
-        # Write to file
+        # Dump to temp file first (faulthandler needs real file descriptor)
+        tmp_path = _watchdog_log + ".tmp"
+        with open(tmp_path, "w", encoding="utf-8") as tmp:
+            faulthandler.dump_traceback(file=tmp, all_threads=True)
+        with open(tmp_path, "r", encoding="utf-8") as tmp:
+            dump = tmp.read()
+
+        # Write to persistent log
         with open(_watchdog_log, "a", encoding="utf-8") as f:
             f.write(f"\\n=== WATCHDOG TICK {tick} ({time.strftime('%H:%M:%S')}) ===\\n")
             f.write(dump)
             f.write("=== END ===\\n")
             f.flush()
-            os.fsync(f.fileno())
 
         # Also print
         print(f"\\n=== WATCHDOG TICK {tick} ===", flush=True)
@@ -554,22 +530,19 @@ def _to_shm(obj, registry, visited=None):
         result["__was_tensor__"] = True
         return result
 
+    # trimesh.Trimesh → pickle → shared memory (preserves visual, metadata, normals)
     if t == 'Trimesh':
-        verts = np.ascontiguousarray(obj.vertices, dtype=np.float64)
-        faces = np.ascontiguousarray(obj.faces, dtype=np.int64)
+        import pickle
+        mesh_bytes = pickle.dumps(obj)
 
-        v_block = shm.SharedMemory(create=True, size=verts.nbytes)
-        np.ndarray(verts.shape, verts.dtype, buffer=v_block.buf)[:] = verts
-        registry.append(v_block)
-
-        f_block = shm.SharedMemory(create=True, size=faces.nbytes)
-        np.ndarray(faces.shape, faces.dtype, buffer=f_block.buf)[:] = faces
-        registry.append(f_block)
+        block = shm.SharedMemory(create=True, size=len(mesh_bytes))
+        block.buf[:len(mesh_bytes)] = mesh_bytes
+        registry.append(block)
 
         result = {
             "__shm_trimesh__": True,
-            "v_name": v_block.name, "v_shape": list(verts.shape),
-            "f_name": f_block.name, "f_shape": list(faces.shape),
+            "name": block.name,
+            "size": len(mesh_bytes),
         }
         visited[obj_id] = result
         return result
@@ -600,17 +573,13 @@ def _from_shm(obj):
             import torch
             return torch.from_numpy(arr)
         return arr
+    # trimesh (pickled to preserve visual, metadata, normals)
     if "__shm_trimesh__" in obj:
-        import trimesh
-        v_block = shm.SharedMemory(name=obj["v_name"])
-        verts = np.ndarray(tuple(obj["v_shape"]), dtype=np.float64, buffer=v_block.buf).copy()
-        v_block.close()
-
-        f_block = shm.SharedMemory(name=obj["f_name"])
-        faces = np.ndarray(tuple(obj["f_shape"]), dtype=np.int64, buffer=f_block.buf).copy()
-        f_block.close()
-
-        return trimesh.Trimesh(vertices=verts, faces=faces, process=False)
+        import pickle
+        block = shm.SharedMemory(name=obj["name"])
+        mesh_bytes = bytes(block.buf[:obj["size"]])
+        block.close()
+        return pickle.loads(mesh_bytes)
     return {k: _from_shm(v) for k, v in obj.items()}
 
 def _cleanup_shm(registry):

{comfy_env-0.1.10.dist-info → comfy_env-0.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.1.10
+Version: 0.1.12
 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

{comfy_env-0.1.10.dist-info → comfy_env-0.1.12.dist-info}/RECORD

@@ -2,15 +2,15 @@ comfy_env/__init__.py,sha256=s0RkyKsBlDiSI4ZSwivtWLvYhc8DS0CUEWgFLVJbtLA,2176
 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=nR-LctovXYTqk-seHovq9W_Ll0hlLeGMw-SQsa6IkBM,5235
+comfy_env/nodes.py,sha256=tUbsUdjnJCUUoxM7NpsdUuawuIz1exfOmWdsLGILXiY,5391
 comfy_env/prestartup.py,sha256=aKuW07R0CmoeIXukENJZnGMPzCv7kU7azvHgIOt2usk,5813
 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=9pxlrO2qUP-4Aov9LUXhgqkDw8V4FT-M-YPeDRXUjuE,13664
+comfy_env/isolation/wrap.py,sha256=cTRzbdHJncmg4yUAyH5n9TPBu88grv6D1XezZwXKpok,14638
 comfy_env/pixi/__init__.py,sha256=BUrq7AQf3WDm0cHWh72B2xZbURNnDu2dCuELWiQCUiM,997
-comfy_env/pixi/core.py,sha256=jy1CAaryPlldCm9bGq6i2UnPckYqyqzQELSDhQsB8ho,19958
+comfy_env/pixi/core.py,sha256=fqozZZEoub8dAQaE6v6gyqw1mMiAYiCcdzH0gjCANBo,20637
 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
@@ -23,10 +23,10 @@ comfy_env/templates/comfy-env.toml,sha256=ROIqi4BlPL1MEdL1VgebfTHpdwPNYGHwWeigI9
 comfy_env/workers/__init__.py,sha256=TMVG55d2XLP1mJ3x1d16H0SBDJZtk2kMC5P4HLk9TrA,1073
 comfy_env/workers/base.py,sha256=4ZYTaQ4J0kBHCoO_OfZnsowm4rJCoqinZUaOtgkOPbw,2307
 comfy_env/workers/mp.py,sha256=vsxDGWepmSNgfqBhZPW7h8yOiKEyQcDFYP09masLTV4,32337
-comfy_env/workers/subprocess.py,sha256=neggSmCqJxfiIOCUQwn_TrDONFJoT5veBZuMjDYf_LA,58537
+comfy_env/workers/subprocess.py,sha256=bNwHpgz_EIIwZVRlgsx_ZEowYRrWbp-8uUIboacc-7M,57136
 comfy_env/workers/tensor_utils.py,sha256=TCuOAjJymrSbkgfyvcKtQ_KbVWTqSwP9VH_bCaFLLq8,6409
-comfy_env-0.1.10.dist-info/METADATA,sha256=tfO_Jhe-jz6XY_AHhfnHroJAVuAzDAe4evf9FYY3nw0,6971
-comfy_env-0.1.10.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.1.10.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.1.10.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.1.10.dist-info/RECORD,,
+comfy_env-0.1.12.dist-info/METADATA,sha256=J41pwCOTdj_2zckDDKjse-HfGWErDaDX3Hire4lKwgM,6971
+comfy_env-0.1.12.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.1.12.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.1.12.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.1.12.dist-info/RECORD,,