comfy-env 0.1.18__tar.gz → 0.1.20__tar.gz

{comfy_env-0.1.18 → comfy_env-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.1.18
+Version: 0.1.20
 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.18 → comfy_env-0.1.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfy-env"
-version = "0.1.18"
+version = "0.1.20"
 description = "Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation"
 readme = "README.md"
 license = {text = "MIT"}

{comfy_env-0.1.18 → comfy_env-0.1.20}/src/comfy_env/isolation/workers/mp.py

@@ -565,7 +565,9 @@ class MPWorker(Worker):
     interpreter without inherited state from the parent.
     """
 
-    def __init__(self, name: Optional[str] = None, sys_path: Optional[list] = None, lib_path: Optional[str] = None, env_vars: Optional[dict] = None):
+    def __init__(self, name: Optional[str] = None, sys_path: Optional[list] = None,
+                 lib_path: Optional[str] = None, env_vars: Optional[dict] = None,
+                 python: Optional[str] = None):
         """
         Initialize the worker.
 
@@ -574,11 +576,15 @@ class MPWorker(Worker):
             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).
             env_vars: Optional environment variables to set in worker process.
+            python: Optional path to venv Python executable for true process isolation.
+                   When provided, spawn uses this Python instead of sys.executable,
+                   avoiding Windows issues where spawn re-imports main.py.
         """
         self.name = name or "MPWorker"
         self._sys_path = sys_path or []
         self._lib_path = lib_path
         self._env_vars = env_vars or {}
+        self._python = python  # Venv Python for true isolation (like pyisolate)
         self._process = None
         self._queue_in = None
         self._queue_out = None
@@ -635,13 +641,18 @@ class MPWorker(Worker):
             # Use spawn to get clean subprocess (no inherited CUDA context)
             ctx = mp.get_context('spawn')
 
-            # Explicitly set the spawn executable to the current Python
-            # This prevents pixi/conda from hijacking the spawn process
+            # Set the spawn executable for true process isolation (like pyisolate)
+            # When venv python is provided, use it to avoid Windows spawn importing main.py
             import multiprocessing.spawn as mp_spawn
             original_exe = mp_spawn.get_executable()
-            if original_exe != sys.executable.encode() and original_exe != sys.executable:
-                print(f"[comfy-env] Warning: spawn executable was {original_exe}, forcing to {sys.executable}")
-            mp_spawn.set_executable(sys.executable)
+            if self._python:
+                # True isolation: use venv Python (fixes Windows spawn __main__ issue)
+                mp_spawn.set_executable(self._python)
+            else:
+                # Fallback: use current Python (may fail on Windows with ComfyUI)
+                if original_exe != sys.executable.encode() and original_exe != sys.executable:
+                    print(f"[comfy-env] Warning: spawn executable was {original_exe}, forcing to {sys.executable}")
+                mp_spawn.set_executable(sys.executable)
 
             self._queue_in = ctx.Queue()
             self._queue_out = ctx.Queue()

{comfy_env-0.1.18 → comfy_env-0.1.20}/src/comfy_env/isolation/workers/subprocess.py

@@ -533,6 +533,21 @@ if sys.platform == "win32":
 from multiprocessing import shared_memory as shm
 import numpy as np
 
+
+def _prepare_trimesh_for_pickle(mesh):
+    """
+    Prepare a trimesh object for cross-Python-version pickling.
+    Strips native extension helpers that cause import errors.
+    """
+    mesh = mesh.copy()
+    for attr in ('ray', '_ray', 'permutate', 'nearest'):
+        try:
+            delattr(mesh, attr)
+        except AttributeError:
+            pass
+    return mesh
+
+
 def _to_shm(obj, registry, visited=None):
     """Serialize to shared memory. Returns JSON-safe metadata."""
     if visited is None:

{comfy_env-0.1.18 → comfy_env-0.1.20}/src/comfy_env/isolation/wrap.py

@@ -74,16 +74,20 @@ def _get_worker(env_dir: Path, working_dir: Path, sys_path: list[str],
 
         host_ver = f"{sys.version_info.major}.{sys.version_info.minor}"
         iso_ver = _get_python_version(env_dir)
+        python = env_dir / ("python.exe" if sys.platform == "win32" else "bin/python")
 
         if iso_ver and iso_ver != host_ver:
+            # Different Python version - must use SubprocessWorker
             from .workers.subprocess import SubprocessWorker
-            python = env_dir / ("python.exe" if sys.platform == "win32" else "bin/python")
             print(f"[comfy-env] SubprocessWorker: {python} ({iso_ver} vs {host_ver})")
             worker = SubprocessWorker(python=str(python), working_dir=working_dir, sys_path=sys_path, name=working_dir.name)
         else:
+            # Same version - use MPWorker with venv Python for true isolation (like pyisolate)
+            # This fixes Windows where spawn would otherwise re-import main.py
             from .workers.mp import MPWorker
-            print(f"[comfy-env] MPWorker: {env_dir}")
-            worker = MPWorker(name=working_dir.name, sys_path=sys_path, lib_path=lib_path, env_vars=env_vars)
+            print(f"[comfy-env] MPWorker: {python}")
+            worker = MPWorker(name=working_dir.name, sys_path=sys_path, lib_path=lib_path,
+                            env_vars=env_vars, python=str(python))
 
         _workers[cache_key] = worker
         return worker