comfy-env 0.0.49__py3-none-any.whl → 0.0.51__py3-none-any.whl

comfy_env/workers/venv.py

@@ -572,8 +572,13 @@ import json
 import socket
 import struct
 import traceback
+import faulthandler
 from types import SimpleNamespace
 
+# Enable faulthandler to dump traceback on SIGSEGV/SIGABRT/etc
+faulthandler.enable(file=sys.stderr, all_threads=True)
+print("[worker] Faulthandler enabled", flush=True)
+
 # On Windows, add host Python's DLL directories so packages like opencv can find VC++ runtime
 if sys.platform == "win32":
     _host_python_dir = os.environ.get("COMFYUI_HOST_PYTHON_DIR")
@@ -587,6 +592,92 @@ if sys.platform == "win32":
         except Exception:
             pass
 
+# =============================================================================
+# Object Reference System - keep complex objects in worker, pass refs to host
+# =============================================================================
+
+_object_cache = {}  # Maps ref_id -> object
+_object_ids = {}    # Maps id(obj) -> ref_id (for deduplication)
+_ref_counter = 0
+
+def _cache_object(obj):
+    """Store object in cache, return reference ID. Deduplicates by object id."""
+    global _ref_counter
+    obj_id = id(obj)
+
+    # Return existing ref if we've seen this object
+    if obj_id in _object_ids:
+        return _object_ids[obj_id]
+
+    ref_id = f"ref_{_ref_counter:08x}"
+    _ref_counter += 1
+    _object_cache[ref_id] = obj
+    _object_ids[obj_id] = ref_id
+    return ref_id
+
+def _resolve_ref(ref_id):
+    """Get object from cache by reference ID."""
+    return _object_cache.get(ref_id)
+
+def _should_use_reference(obj):
+    """Check if object should be passed by reference instead of value."""
+    if obj is None:
+        return False
+    # Primitives - pass by value
+    if isinstance(obj, (bool, int, float, str, bytes)):
+        return False
+    # NumPy arrays and torch tensors - pass by value (they serialize well)
+    obj_type = type(obj).__name__
+    if obj_type in ('ndarray', 'Tensor'):
+        return False
+    # Dicts, lists, tuples - recurse into contents (don't ref the container)
+    if isinstance(obj, (dict, list, tuple)):
+        return False
+    # Everything else (trimesh, custom classes) - pass by reference
+    return True
+
+def _serialize_result(obj, visited=None):
+    """Convert result for IPC - complex objects become references."""
+    if visited is None:
+        visited = set()
+
+    obj_id = id(obj)
+    if obj_id in visited:
+        # Circular reference - use existing ref or create one
+        if obj_id in _object_ids:
+            return {"__comfy_ref__": _object_ids[obj_id], "__class__": type(obj).__name__}
+        return None  # Skip circular refs to primitives
+
+    if _should_use_reference(obj):
+        ref_id = _cache_object(obj)
+        return {"__comfy_ref__": ref_id, "__class__": type(obj).__name__}
+
+    visited.add(obj_id)
+
+    if isinstance(obj, dict):
+        return {k: _serialize_result(v, visited) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_serialize_result(v, visited) for v in obj]
+    if isinstance(obj, tuple):
+        return tuple(_serialize_result(v, visited) for v in obj)
+    return obj
+
+def _deserialize_input(obj):
+    """Convert input from IPC - references become real objects."""
+    if isinstance(obj, dict):
+        if "__comfy_ref__" in obj:
+            ref_id = obj["__comfy_ref__"]
+            real_obj = _resolve_ref(ref_id)
+            if real_obj is None:
+                raise ValueError(f"Object reference not found: {ref_id}")
+            return real_obj
+        return {k: _deserialize_input(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_deserialize_input(v) for v in obj]
+    if isinstance(obj, tuple):
+        return tuple(_deserialize_input(v) for v in obj)
+    return obj
+
 
 class SocketTransport:
     """Length-prefixed JSON transport."""
@@ -655,20 +746,24 @@ def _deserialize_isolated_objects(obj):
 
 
 def main():
+    print("[worker] Starting...", flush=True)
     # Get socket address from command line
     if len(sys.argv) < 2:
         print("Usage: worker.py <socket_addr>", file=sys.stderr)
         sys.exit(1)
     socket_addr = sys.argv[1]
+    print(f"[worker] Connecting to {socket_addr}...", flush=True)
 
     # Connect to host process
     sock = _connect(socket_addr)
     transport = SocketTransport(sock)
+    print("[worker] Connected, waiting for config...", flush=True)
 
     # Read config as first message
     config = transport.recv()
     if not config:
         return
+    print("[worker] Got config, setting up paths...", flush=True)
 
     # Setup sys.path
     for p in config.get("sys_paths", []):
@@ -676,10 +771,13 @@ def main():
             sys.path.insert(0, p)
 
     # Import torch after path setup
+    print("[worker] Importing torch...", flush=True)
     import torch
+    print(f"[worker] Torch imported: {torch.__version__}", flush=True)
 
     # Signal ready
     transport.send({"status": "ready"})
+    print("[worker] Ready, entering request loop...", flush=True)
 
     # Process requests
     while True:
@@ -698,36 +796,50 @@ def main():
             module_name = request["module"]
             inputs_path = request.get("inputs_path")
             outputs_path = request.get("outputs_path")
+            print(f"[worker] Request: {request_type} {module_name}", flush=True)
 
             # Load inputs
             if inputs_path:
+                print(f"[worker] Loading inputs from {inputs_path}...", flush=True)
                 inputs = torch.load(inputs_path, weights_only=False)
+                print(f"[worker] Deserializing isolated objects...", flush=True)
                 inputs = _deserialize_isolated_objects(inputs)
+                # Resolve any object references from previous node calls
+                print(f"[worker] Resolving object references...", flush=True)
+                inputs = _deserialize_input(inputs)
+                print(f"[worker] Inputs ready: {list(inputs.keys())}", flush=True)
             else:
                 inputs = {}
 
             # Import module
+            print(f"[worker] Importing module {module_name}...", flush=True)
             module = __import__(module_name, fromlist=[""])
+            print(f"[worker] Module imported", flush=True)
 
             if request_type == "call_method":
                 class_name = request["class_name"]
                 method_name = request["method_name"]
                 self_state = request.get("self_state")
+                print(f"[worker] Getting class {class_name}...", flush=True)
 
                 cls = getattr(module, class_name)
+                print(f"[worker] Creating instance...", flush=True)
                 instance = object.__new__(cls)
                 if self_state:
                     instance.__dict__.update(self_state)
+                print(f"[worker] Calling {method_name}...", flush=True)
                 method = getattr(instance, method_name)
                 result = method(**inputs)
+                print(f"[worker] Method returned", flush=True)
             else:
                 func_name = request["func"]
                 func = getattr(module, func_name)
                 result = func(**inputs)
 
-            # Save result
+            # Save result - convert complex objects to references
             if outputs_path:
-                torch.save(result, outputs_path)
+                serialized_result = _serialize_result(result)
+                torch.save(serialized_result, outputs_path)
 
             transport.send({"status": "ok"})
 
@@ -803,6 +915,10 @@ class PersistentVenvWorker(Worker):
         self._socket_addr: Optional[str] = None
         self._transport: Optional[SocketTransport] = None
 
+        # Stderr buffer for crash diagnostics
+        self._stderr_buffer: List[str] = []
+        self._stderr_lock = threading.Lock()
+
         # Write worker script to temp file
         self._worker_script = self._temp_dir / "persistent_worker.py"
         self._worker_script.write_text(_PERSISTENT_WORKER_SCRIPT)
@@ -875,13 +991,17 @@ class PersistentVenvWorker(Worker):
             [str(self.python), str(self._worker_script), self._socket_addr],
             stdin=subprocess.DEVNULL,
             stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,  # Merge stdout/stderr for forwarding
+            stderr=subprocess.PIPE,  # Capture stderr separately for crash diagnostics
             cwd=str(self.working_dir),
             env=env,
         )
 
-        # Start output forwarding thread
-        def forward_output():
+        # Clear stderr buffer for new process
+        with self._stderr_lock:
+            self._stderr_buffer.clear()
+
+        # Start stdout forwarding thread
+        def forward_stdout():
             try:
                 for line in self._process.stdout:
                     if isinstance(line, bytes):
@@ -890,22 +1010,43 @@ class PersistentVenvWorker(Worker):
                     sys.stderr.flush()
             except:
                 pass
-        self._output_thread = threading.Thread(target=forward_output, daemon=True)
-        self._output_thread.start()
+        self._stdout_thread = threading.Thread(target=forward_stdout, daemon=True)
+        self._stdout_thread.start()
+
+        # Start stderr capture thread (buffer for crash diagnostics)
+        def capture_stderr():
+            try:
+                for line in self._process.stderr:
+                    if isinstance(line, bytes):
+                        line = line.decode('utf-8', errors='replace')
+                    # Print to terminal AND buffer for crash reporting
+                    sys.stderr.write(f"  [stderr] {line}")
+                    sys.stderr.flush()
+                    with self._stderr_lock:
+                        self._stderr_buffer.append(line.rstrip())
+                        # Keep last 50 lines
+                        if len(self._stderr_buffer) > 50:
+                            self._stderr_buffer.pop(0)
+            except:
+                pass
+        self._stderr_thread = threading.Thread(target=capture_stderr, daemon=True)
+        self._stderr_thread.start()
 
         # Accept connection from worker with timeout
         self._server_socket.settimeout(60)
         try:
             client_sock, _ = self._server_socket.accept()
         except socket.timeout:
-            stderr = ""
+            # Collect stderr from buffer
+            time.sleep(0.2)  # Give stderr thread time to capture
+            with self._stderr_lock:
+                stderr = "\n".join(self._stderr_buffer) if self._stderr_buffer else "(no stderr captured)"
             try:
                 self._process.kill()
-                stdout, _ = self._process.communicate(timeout=5)
-                stderr = stdout.decode('utf-8', errors='replace') if stdout else ""
+                self._process.wait(timeout=5)
             except:
                 pass
-            raise RuntimeError(f"{self.name}: Worker failed to connect (timeout). output: {stderr}")
+            raise RuntimeError(f"{self.name}: Worker failed to connect (timeout).\nStderr:\n{stderr}")
         finally:
             self._server_socket.settimeout(None)
 
@@ -946,7 +1087,33 @@ class PersistentVenvWorker(Worker):
         self._transport.send(request)
 
         # Read response with timeout
-        response = self._transport.recv(timeout=timeout)
+        try:
+            response = self._transport.recv(timeout=timeout)
+        except ConnectionError as e:
+            # Socket closed - check if worker process died
+            self._shutdown = True
+            time.sleep(0.2)  # Give process time to fully exit and stderr to flush
+            exit_code = None
+            if self._process:
+                exit_code = self._process.poll()
+
+            # Get captured stderr
+            with self._stderr_lock:
+                stderr_output = "\n".join(self._stderr_buffer) if self._stderr_buffer else "(no stderr captured)"
+
+            if exit_code is not None:
+                raise RuntimeError(
+                    f"{self.name}: Worker process died with exit code {exit_code}. "
+                    f"This usually indicates a crash in native code (CGAL, pymeshlab, etc.).\n"
+                    f"Stderr:\n{stderr_output}"
+                ) from e
+            else:
+                # Process still alive but socket closed - something weird
+                raise RuntimeError(
+                    f"{self.name}: Socket closed but worker process still running. "
+                    f"This may indicate a protocol error or worker bug.\n"
+                    f"Stderr:\n{stderr_output}"
+                ) from e
 
         if response is None:
             # Timeout - kill process

{comfy_env-0.0.49.dist-info → comfy_env-0.0.51.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.49
+Version: 0.0.51
 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
@@ -84,9 +84,47 @@ from comfy_env import install
 install()
 ```
 
-### Process Isolation (Type 1 - Separate Venv)
+### Process Isolation (Type 1 - Separate Environment)
 
-For nodes that need completely separate dependencies:
+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
@@ -266,7 +304,27 @@ vars_dict = env.as_dict()
 # {'cuda_version': '12.8', 'cuda_short': '128', 'torch_mm': '28', ...}
 ```
 
-### Workers (for isolation)
+### 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

{comfy_env-0.0.49.dist-info → comfy_env-0.0.51.dist-info}/RECORD

@@ -1,15 +1,17 @@
-comfy_env/__init__.py,sha256=OQJFNjmArjLcgrfHAFxgDJQFH_IhxibqMXbU5bu_j9Q,3822
+comfy_env/__init__.py,sha256=DvOCFCq-EuXZ_e6vsPCObgTPYSRLZqiG3w35SOD-e4E,4101
 comfy_env/cli.py,sha256=Pjzb-jsoH67lyHxmBFOWvasWX01eHFE_BEjUk1l-uEo,14509
-comfy_env/decorator.py,sha256=sCb3DQIYYdt8fuMiJnmNfU8oLawbfjMMR2Hf0YMT4B0,16738
+comfy_env/decorator.py,sha256=bL0eUjXf5UAGbsT2zilZbO0e8ZbhtQAR3vDJLbMO3ZI,27018
 comfy_env/errors.py,sha256=8hN8NDlo8oBUdapc-eT3ZluigI5VBzfqsSBvQdfWlz4,9943
-comfy_env/install.py,sha256=m4NKlfCcQGI5xzVRjHw3ep-lWbqx5kE1e21sUUZ2Leo,17528
+comfy_env/install.py,sha256=b2eXFqQ58pUBWpwc1AhymbTh7dGRMnEuq5FoZot0CO0,15661
+comfy_env/isolation.py,sha256=wuze8TmkRbdMfrg2cj9quoGYJWsxKcc5iiDvmLWX16g,8680
 comfy_env/nodes.py,sha256=CWUe35jU5SKk4ur-SddZePdqWgxJDlxGhpcJiu5pAK4,4354
-comfy_env/pixi.py,sha256=VyPYL6hV7rxMUJcUl-8UobwTpOTzaSEmvRKT8v5a0vo,15250
+comfy_env/pixi.py,sha256=p3qP-4l95-toOI3-N2luJQ7kB-KLbalDB6yEJjmfzoc,19574
 comfy_env/registry.py,sha256=w-QwvAPFlCrBYRAv4cXkp2zujQPZn8Fk5DUxKCtox8o,3430
 comfy_env/resolver.py,sha256=WoNIo2IfTR2RlEf_HQl66eAeMa2R2pmLof_UdK-0RNE,6714
+comfy_env/stub_imports.py,sha256=s84q8x5156ZkHNJhbuDqMhU_c-0ux51Rhe1aoVcGrj4,8920
 comfy_env/env/__init__.py,sha256=imQdoQEQvrRT-QDtyNpFlkVbm2fBzgACdpQwRPd09fI,1157
-comfy_env/env/config.py,sha256=Ila-5Yal3bj6jENbBeYJlZtkbgdwnzJzImVZK3ZF1lg,7645
-comfy_env/env/config_file.py,sha256=HzFKeQh9zQ--K1V-XuvgE6DiE_bYrXrChL1ZT8Tzlq4,24684
+comfy_env/env/config.py,sha256=cRSuWiVZGSK9xpvyNIyMirlHyfTm6_AB_eXzeKyvfnc,7749
+comfy_env/env/config_file.py,sha256=g6fZq6XbTUXx97meWW_7xfKcuC0sN002c7fBvR0eCOg,24819
 comfy_env/env/cuda_gpu_detection.py,sha256=YLuXUdWg6FeKdNyLlQAHPlveg4rTenXJ2VbeAaEi9QE,9755
 comfy_env/env/manager.py,sha256=-qdbZDsbNfs70onVbC7mhKCzNsxYx3WmG7ttlBinhGI,23659
 comfy_env/env/security.py,sha256=dNSitAnfBNVdvxgBBntYw33AJaCs_S1MHb7KJhAVYzM,8171
@@ -30,17 +32,17 @@ comfy_env/stubs/folder_paths.py,sha256=K90J34EG6LD4eZP8YG-xMeBmqwpp_wA8E92DKMXd1
 comfy_env/stubs/comfy/__init__.py,sha256=-y4L6gX21vrI2V8MvNaMeHOcAn5kUNK3jUyLvtXRmJQ,173
 comfy_env/stubs/comfy/model_management.py,sha256=Khx8Qa3NutKPLTn9oSM3VLeATUOg1fe4QCjxdxXd6eE,1462
 comfy_env/stubs/comfy/utils.py,sha256=s3t_KLj_-w1Uj3A3iAy69wIk4Ggklojw5hsDNb69Pcc,776
-comfy_env/templates/comfy-env-instructions.txt,sha256=pXxlyOxWKq8NYtxIsa9wD8Y3qzC8JUWguTPiV9dB0Mw,2481
-comfy_env/templates/comfy-env.toml,sha256=1CyphZu9DVc-EKzkLiDCnNzY9AWH5s_Kp9o4s2Fnw9g,7441
+comfy_env/templates/comfy-env-instructions.txt,sha256=Q38Hb_YdN0a8rTxn7l5ON4JDPba7XgVftDqfEy-8I2I,3004
+comfy_env/templates/comfy-env.toml,sha256=v6nxvCWWKSlIpn4m-WqCkzJt4ObJsklbr9KBJt0r5fU,6729
 comfy_env/workers/__init__.py,sha256=IKZwOvrWOGqBLDUIFAalg4CdqzJ_YnAdxo2Ha7gZTJ0,1467
 comfy_env/workers/base.py,sha256=ZILYXlvGCWuCZXmjKqfG8VeD19ihdYaASdlbasl2BMo,2312
 comfy_env/workers/pool.py,sha256=MtjeOWfvHSCockq8j1gfnxIl-t01GSB79T5N4YB82Lg,6956
 comfy_env/workers/tensor_utils.py,sha256=TCuOAjJymrSbkgfyvcKtQ_KbVWTqSwP9VH_bCaFLLq8,6409
 comfy_env/workers/torch_mp.py,sha256=TnsCoBHEJBXEoBkx7WiCd9tBAlzFtMOw1dk_7_zGJZY,22288
-comfy_env/workers/venv.py,sha256=kAaADoUJpKItZoG73YZhn0ufqzHmDgU1xeSHNCiZ77I,38941
+comfy_env/workers/venv.py,sha256=MXN0KRlIPREEgJKM-4_sXHQw4Dv8hLFGohmway6y3UU,46393
 comfy_env/wheel_sources.yml,sha256=uU0YJmWaiLAicQNN9VYS8PZevlP2NOH6mBUE294dvAo,8156
-comfy_env-0.0.49.dist-info/METADATA,sha256=Ve0XcboM1LLVeXVFYTbBDMxIcefaYiYnC8Nf84inrhQ,7138
-comfy_env-0.0.49.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.0.49.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.0.49.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.0.49.dist-info/RECORD,,
+comfy_env-0.0.51.dist-info/METADATA,sha256=6DlmPszS1Q0lDXK1I0YXfkbaKPQyZKiZN7PsXQuVSHk,8735
+comfy_env-0.0.51.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.0.51.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.0.51.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.0.51.dist-info/RECORD,,