comfy-env 0.0.44__py3-none-any.whl → 0.0.45__py3-none-any.whl

comfy_env/env/manager.py

@@ -4,6 +4,7 @@ IsolatedEnvManager - Creates and manages isolated Python environments.
 Uses uv for fast environment creation and package installation.
 """
 
+import os
 import subprocess
 import shutil
 import sys
@@ -453,10 +454,24 @@ class IsolatedEnvManager:
         uv = self._find_uv()
 
         self.log("Installing comfy-env (for worker support)...")
+
+        # Check for local wheel in COMFY_LOCAL_WHEELS directory (set by comfy-test --local)
+        install_target = "comfy-env @ git+https://github.com/PozzettiAndrea/comfy-env"
+        wheels_dir = os.environ.get("COMFY_LOCAL_WHEELS")
+        self.log(f"  COMFY_LOCAL_WHEELS={wheels_dir}")
+        if wheels_dir:
+            wheels_path = Path(wheels_dir)
+            self.log(f"  Wheels dir exists: {wheels_path.exists()}")
+            if wheels_path.exists():
+                local_wheels = list(wheels_path.glob("comfy_env-*.whl"))
+                self.log(f"  Found wheels: {[w.name for w in local_wheels]}")
+                if local_wheels:
+                    install_target = str(local_wheels[0])
+                    self.log(f"  Using local wheel: {local_wheels[0].name}")
+
         result = subprocess.run(
             [str(uv), "pip", "install", "--python", str(python_exe),
-             "--upgrade", "--no-cache",
-             "comfy-env @ git+https://github.com/PozzettiAndrea/comfy-env"],
+             "--upgrade", "--no-cache", install_target],
             capture_output=True,
             text=True,
         )

comfy_env/wheel_sources.yml

@@ -136,6 +136,6 @@ packages:
   # Note: This uses a special package_name field, not wheel_template
   # ===========================================================================
   spconv:
-    wheel_template: "https://github.com/PozzettiAndrea/cuda-wheels/releases/download/spconv_cu{cuda_short}-latest/spconv-{version}%2Bcu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl"
+    wheel_template: "https://github.com/PozzettiAndrea/cuda-wheels/releases/download/spconv_cu{cuda_short}-latest/spconv_cu{cuda_short}-{version}%2Bcu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl"
     default_version: "2.3.8"
     description: Sparse convolution library

comfy_env/workers/venv.py

@@ -29,6 +29,8 @@ Example:
 import json
 import os
 import shutil
+import socket
+import struct
 import subprocess
 import sys
 import tempfile
@@ -36,11 +38,154 @@ import threading
 import time
 import uuid
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from .base import Worker, WorkerError
 
 
+# =============================================================================
+# Socket IPC utilities - cross-platform with TCP fallback
+# =============================================================================
+
+def _has_af_unix() -> bool:
+    """Check if AF_UNIX sockets are available."""
+    return hasattr(socket, 'AF_UNIX')
+
+
+def _get_socket_dir() -> Path:
+    """Get directory for IPC sockets."""
+    if sys.platform == 'linux' and os.path.isdir('/dev/shm'):
+        return Path('/dev/shm')
+    elif sys.platform == 'win32':
+        return Path(tempfile.gettempdir())
+    else:
+        return Path(tempfile.gettempdir())
+
+
+def _create_server_socket() -> Tuple[socket.socket, str]:
+    """
+    Create a server socket for IPC.
+
+    Returns:
+        Tuple of (socket, address_string).
+        Address string is "unix://path" or "tcp://host:port".
+    """
+    if _has_af_unix():
+        # Unix domain socket (fast, no port conflicts)
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock_path = _get_socket_dir() / f"comfy_worker_{uuid.uuid4().hex[:12]}.sock"
+        # Remove stale socket file if exists
+        try:
+            sock_path.unlink()
+        except FileNotFoundError:
+            pass
+        sock.bind(str(sock_path))
+        sock.listen(1)
+        return sock, f"unix://{sock_path}"
+    else:
+        # TCP localhost fallback (works everywhere)
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind(('127.0.0.1', 0))  # OS picks free port
+        sock.listen(1)
+        port = sock.getsockname()[1]
+        return sock, f"tcp://127.0.0.1:{port}"
+
+
+def _connect_to_socket(addr: str) -> socket.socket:
+    """
+    Connect to a server socket.
+
+    Args:
+        addr: Address string ("unix://path" or "tcp://host:port").
+
+    Returns:
+        Connected socket.
+    """
+    if addr.startswith("unix://"):
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.connect(addr[7:])  # Strip "unix://"
+        return sock
+    elif addr.startswith("tcp://"):
+        host_port = addr[6:]  # Strip "tcp://"
+        host, port = host_port.rsplit(":", 1)
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.connect((host, int(port)))
+        return sock
+    else:
+        raise ValueError(f"Unknown socket address scheme: {addr}")
+
+
+class SocketTransport:
+    """
+    Length-prefixed JSON transport over sockets.
+
+    Message format: [4-byte big-endian length][JSON payload]
+    """
+
+    def __init__(self, sock: socket.socket):
+        self._sock = sock
+        self._send_lock = threading.Lock()
+        self._recv_lock = threading.Lock()
+
+    def send(self, obj: dict) -> None:
+        """Send a JSON-serializable object."""
+        data = json.dumps(obj).encode('utf-8')
+        msg = struct.pack('>I', len(data)) + data
+        with self._send_lock:
+            self._sock.sendall(msg)
+
+    def recv(self, timeout: Optional[float] = None) -> dict:
+        """Receive a JSON object. Returns None on timeout."""
+        with self._recv_lock:
+            if timeout is not None:
+                self._sock.settimeout(timeout)
+            try:
+                # Read 4-byte length header
+                raw_len = self._recvall(4)
+                if not raw_len:
+                    raise ConnectionError("Socket closed")
+                msg_len = struct.unpack('>I', raw_len)[0]
+
+                # Sanity check
+                if msg_len > 100 * 1024 * 1024:  # 100MB limit
+                    raise ValueError(f"Message too large: {msg_len} bytes")
+
+                # Read payload
+                data = self._recvall(msg_len)
+                if len(data) < msg_len:
+                    raise ConnectionError(f"Incomplete message: {len(data)}/{msg_len}")
+
+                return json.loads(data.decode('utf-8'))
+            except socket.timeout:
+                return None
+            finally:
+                if timeout is not None:
+                    self._sock.settimeout(None)
+
+    def _recvall(self, n: int) -> bytes:
+        """Receive exactly n bytes."""
+        data = bytearray()
+        while len(data) < n:
+            chunk = self._sock.recv(n - len(data))
+            if not chunk:
+                return bytes(data)
+            data.extend(chunk)
+        return bytes(data)
+
+    def close(self) -> None:
+        """Close the socket."""
+        try:
+            self._sock.close()
+        except:
+            pass
+
+
+# =============================================================================
+# Serialization helpers
+# =============================================================================
+
+
 def _serialize_for_ipc(obj, visited=None):
     """
     Convert objects with broken __module__ paths to dicts for IPC.
@@ -413,11 +558,13 @@ class VenvWorker(Worker):
 
 
 # Persistent worker script - runs as __main__ in the venv Python subprocess
-# Uses stdin/stdout JSON for IPC - avoids Windows multiprocessing spawn issues entirely
+# Uses Unix socket (or TCP localhost) for IPC - completely separate from stdout/stderr
 _PERSISTENT_WORKER_SCRIPT = '''
 import sys
 import os
 import json
+import socket
+import struct
 import traceback
 from types import SimpleNamespace
 
@@ -434,6 +581,57 @@ if sys.platform == "win32":
         except Exception:
             pass
 
+
+class SocketTransport:
+    """Length-prefixed JSON transport."""
+    def __init__(self, sock):
+        self._sock = sock
+
+    def send(self, obj):
+        data = json.dumps(obj).encode("utf-8")
+        msg = struct.pack(">I", len(data)) + data
+        self._sock.sendall(msg)
+
+    def recv(self):
+        raw_len = self._recvall(4)
+        if not raw_len:
+            return None
+        msg_len = struct.unpack(">I", raw_len)[0]
+        data = self._recvall(msg_len)
+        return json.loads(data.decode("utf-8"))
+
+    def _recvall(self, n):
+        data = bytearray()
+        while len(data) < n:
+            chunk = self._sock.recv(n - len(data))
+            if not chunk:
+                return bytes(data)
+            data.extend(chunk)
+        return bytes(data)
+
+    def close(self):
+        try:
+            self._sock.close()
+        except:
+            pass
+
+
+def _connect(addr):
+    """Connect to server socket (unix:// or tcp://)."""
+    if addr.startswith("unix://"):
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.connect(addr[7:])
+        return sock
+    elif addr.startswith("tcp://"):
+        host_port = addr[6:]
+        host, port = host_port.rsplit(":", 1)
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.connect((host, int(port)))
+        return sock
+    else:
+        raise ValueError(f"Unknown socket scheme: {addr}")
+
+
 def _deserialize_isolated_objects(obj):
     """Reconstruct objects serialized with __isolated_object__ marker."""
     if isinstance(obj, dict):
@@ -449,16 +647,22 @@ def _deserialize_isolated_objects(obj):
         return tuple(_deserialize_isolated_objects(v) for v in obj)
     return obj
 
-def main():
-    # Save original stdout for JSON IPC - redirect stdout to stderr for module prints
-    _ipc_out = sys.stdout
-    sys.stdout = sys.stderr  # All print() calls go to stderr now
 
-    # Read config from first line
-    config_line = sys.stdin.readline()
-    if not config_line:
+def main():
+    # 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]
+
+    # Connect to host process
+    sock = _connect(socket_addr)
+    transport = SocketTransport(sock)
+
+    # Read config as first message
+    config = transport.recv()
+    if not config:
         return
-    config = json.loads(config_line)
 
     # Setup sys.path
     for p in config.get("sys_paths", []):
@@ -468,17 +672,15 @@ def main():
     # Import torch after path setup
     import torch
 
-    # Signal ready (use _ipc_out, not stdout)
-    _ipc_out.write(json.dumps({"status": "ready"}) + "\\n")
-    _ipc_out.flush()
+    # Signal ready
+    transport.send({"status": "ready"})
 
     # Process requests
     while True:
         try:
-            line = sys.stdin.readline()
-            if not line:
+            request = transport.recv()
+            if not request:
                 break
-            request = json.loads(line)
         except Exception:
             break
 
@@ -521,16 +723,16 @@ def main():
             if outputs_path:
                 torch.save(result, outputs_path)
 
-            _ipc_out.write(json.dumps({"status": "ok"}) + "\\n")
-            _ipc_out.flush()
+            transport.send({"status": "ok"})
 
         except Exception as e:
-            _ipc_out.write(json.dumps({
+            transport.send({
                 "status": "error",
                 "error": str(e),
                 "traceback": traceback.format_exc(),
-            }) + "\\n")
-            _ipc_out.flush()
+            })
+
+    transport.close()
 
 if __name__ == "__main__":
     main()
@@ -541,15 +743,16 @@ class PersistentVenvWorker(Worker):
     """
     Persistent version of VenvWorker that keeps subprocess alive.
 
-    Uses subprocess.Popen with stdin/stdout JSON IPC instead of multiprocessing.
-    This avoids Windows multiprocessing spawn issues where the child process
-    tries to reimport __main__ (which fails when using a different Python).
+    Uses Unix domain sockets (or TCP localhost on older Windows) for IPC.
+    This completely separates IPC from stdout/stderr, so C libraries
+    printing to stdout (like Blender) won't corrupt the protocol.
 
     Benefits:
     - Works on Windows with different venv Python (full isolation)
     - Compiled CUDA extensions load correctly in the venv
     - ~50-100ms per call (vs ~300-500ms for VenvWorker per-call spawn)
     - Tensor transfer via shared memory files
+    - Immune to stdout pollution from C libraries
 
     Use this for high-frequency calls to isolated venvs.
     """
@@ -589,6 +792,11 @@ class PersistentVenvWorker(Worker):
         self._shutdown = False
         self._lock = threading.Lock()
 
+        # Socket IPC
+        self._server_socket: Optional[socket.socket] = None
+        self._socket_addr: Optional[str] = None
+        self._transport: Optional[SocketTransport] = None
+
         # Write worker script to temp file
         self._worker_script = self._temp_dir / "persistent_worker.py"
         self._worker_script.write_text(_PERSISTENT_WORKER_SCRIPT)
@@ -619,6 +827,17 @@ class PersistentVenvWorker(Worker):
         if self._process is not None and self._process.poll() is None:
             return  # Already running
 
+        # Clean up any previous socket
+        if self._transport:
+            self._transport.close()
+            self._transport = None
+        if self._server_socket:
+            self._server_socket.close()
+            self._server_socket = None
+
+        # Create server socket for IPC
+        self._server_socket, self._socket_addr = _create_server_socket()
+
         # Set up environment
         env = os.environ.copy()
         env.update(self.extra_env)
@@ -638,69 +857,55 @@ class PersistentVenvWorker(Worker):
         stubs_dir = Path(__file__).parent.parent / "stubs"
         all_sys_path = [str(stubs_dir), str(self.working_dir)] + self.sys_path
 
-        # Launch subprocess with the venv Python
-        # This runs _PERSISTENT_WORKER_SCRIPT as __main__ - no reimport issues!
+        # Launch subprocess with the venv Python, passing socket address
         self._process = subprocess.Popen(
-            [str(self.python), str(self._worker_script)],
-            stdin=subprocess.PIPE,
+            [str(self.python), str(self._worker_script), self._socket_addr],
+            stdin=subprocess.DEVNULL,
             stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
+            stderr=subprocess.STDOUT,  # Merge stdout/stderr for forwarding
             cwd=str(self.working_dir),
             env=env,
-            bufsize=1,  # Line buffered
-            text=True,  # Text mode for JSON
         )
 
-        # Start stderr forwarding thread to show worker output in real-time
-        def forward_stderr():
+        # Start output forwarding thread
+        def forward_output():
             try:
-                for line in self._process.stderr:
-                    # Forward to main process stderr (visible in console)
+                for line in self._process.stdout:
+                    if isinstance(line, bytes):
+                        line = line.decode('utf-8', errors='replace')
                     sys.stderr.write(f"  {line}")
                     sys.stderr.flush()
             except:
                 pass
-        self._stderr_thread = threading.Thread(target=forward_stderr, daemon=True)
-        self._stderr_thread.start()
+        self._output_thread = threading.Thread(target=forward_output, daemon=True)
+        self._output_thread.start()
 
-        # Send config
-        config = {"sys_paths": all_sys_path}
-        self._process.stdin.write(json.dumps(config) + "\n")
-        self._process.stdin.flush()
-
-        # Wait for ready signal with timeout
-        import select
-        if sys.platform == "win32":
-            # Windows: can't use select on pipes, use thread with timeout
-            ready_line = [None]
-            def read_ready():
-                try:
-                    ready_line[0] = self._process.stdout.readline()
-                except:
-                    pass
-            t = threading.Thread(target=read_ready, daemon=True)
-            t.start()
-            t.join(timeout=60)
-            line = ready_line[0]
-        else:
-            # Unix: use select for timeout
-            import select
-            ready, _, _ = select.select([self._process.stdout], [], [], 60)
-            line = self._process.stdout.readline() if ready else None
-
-        if not line:
+        # Accept connection from worker with timeout
+        self._server_socket.settimeout(60)
+        try:
+            client_sock, _ = self._server_socket.accept()
+        except socket.timeout:
             stderr = ""
             try:
                 self._process.kill()
-                _, stderr = self._process.communicate(timeout=5)
+                stdout, _ = self._process.communicate(timeout=5)
+                stderr = stdout.decode('utf-8', errors='replace') if stdout else ""
             except:
                 pass
-            raise RuntimeError(f"{self.name}: Worker failed to start (timeout). stderr: {stderr}")
+            raise RuntimeError(f"{self.name}: Worker failed to connect (timeout). output: {stderr}")
+        finally:
+            self._server_socket.settimeout(None)
 
-        try:
-            msg = json.loads(line)
-        except json.JSONDecodeError as e:
-            raise RuntimeError(f"{self.name}: Invalid ready message: {line!r}") from e
+        self._transport = SocketTransport(client_sock)
+
+        # Send config
+        config = {"sys_paths": all_sys_path}
+        self._transport.send(config)
+
+        # Wait for ready signal
+        msg = self._transport.recv(timeout=60)
+        if not msg:
+            raise RuntimeError(f"{self.name}: Worker failed to send ready signal")
 
         if msg.get("status") != "ready":
             raise RuntimeError(f"{self.name}: Unexpected ready message: {msg}")
@@ -718,31 +923,17 @@ class PersistentVenvWorker(Worker):
         )
 
     def _send_request(self, request: dict, timeout: float) -> dict:
-        """Send request via stdin and read response from stdout with timeout."""
+        """Send request via socket and read response with timeout."""
+        if not self._transport:
+            raise RuntimeError(f"{self.name}: Transport not initialized")
+
         # Send request
-        self._process.stdin.write(json.dumps(request) + "\n")
-        self._process.stdin.flush()
+        self._transport.send(request)
 
         # Read response with timeout
-        if sys.platform == "win32":
-            # Windows: use thread for timeout
-            response_line = [None]
-            def read_response():
-                try:
-                    response_line[0] = self._process.stdout.readline()
-                except:
-                    pass
-            t = threading.Thread(target=read_response, daemon=True)
-            t.start()
-            t.join(timeout=timeout)
-            line = response_line[0]
-        else:
-            # Unix: use select
-            import select
-            ready, _, _ = select.select([self._process.stdout], [], [], timeout)
-            line = self._process.stdout.readline() if ready else None
+        response = self._transport.recv(timeout=timeout)
 
-        if not line:
+        if response is None:
             # Timeout - kill process
             try:
                 self._process.kill()
@@ -751,10 +942,7 @@ class PersistentVenvWorker(Worker):
             self._shutdown = True
             raise TimeoutError(f"{self.name}: Call timed out after {timeout}s")
 
-        try:
-            return json.loads(line)
-        except json.JSONDecodeError as e:
-            raise WorkerError(f"Invalid response from worker: {line!r}") from e
+        return response
 
     def call_method(
         self,
@@ -882,16 +1070,33 @@ class PersistentVenvWorker(Worker):
             return
         self._shutdown = True
 
-        # Send shutdown signal via stdin
-        if self._process and self._process.poll() is None:
+        # Send shutdown signal via socket
+        if self._transport and self._process and self._process.poll() is None:
             try:
-                self._process.stdin.write(json.dumps({"method": "shutdown"}) + "\n")
-                self._process.stdin.flush()
-                self._process.stdin.close()
+                self._transport.send({"method": "shutdown"})
             except:
                 pass
 
-            # Wait for process to exit
+        # Close transport and socket
+        if self._transport:
+            self._transport.close()
+            self._transport = None
+
+        if self._server_socket:
+            try:
+                self._server_socket.close()
+            except:
+                pass
+            # Clean up unix socket file
+            if self._socket_addr and self._socket_addr.startswith("unix://"):
+                try:
+                    Path(self._socket_addr[7:]).unlink()
+                except:
+                    pass
+            self._server_socket = None
+
+        # Wait for process to exit
+        if self._process and self._process.poll() is None:
             try:
                 self._process.wait(timeout=5)
             except subprocess.TimeoutExpired:

{comfy_env-0.0.44.dist-info → comfy_env-0.0.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.44
+Version: 0.0.45
 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.0.44.dist-info → comfy_env-0.0.45.dist-info}/RECORD

@@ -11,7 +11,7 @@ comfy_env/env/__init__.py,sha256=imQdoQEQvrRT-QDtyNpFlkVbm2fBzgACdpQwRPd09fI,115
 comfy_env/env/config.py,sha256=Ila-5Yal3bj6jENbBeYJlZtkbgdwnzJzImVZK3ZF1lg,7645
 comfy_env/env/config_file.py,sha256=HzFKeQh9zQ--K1V-XuvgE6DiE_bYrXrChL1ZT8Tzlq4,24684
 comfy_env/env/cuda_gpu_detection.py,sha256=YLuXUdWg6FeKdNyLlQAHPlveg4rTenXJ2VbeAaEi9QE,9755
-comfy_env/env/manager.py,sha256=C-lniAu1dhgUViNtl-78c7ZkiQMnbsaUGpIVi51Uzw8,22909
+comfy_env/env/manager.py,sha256=-qdbZDsbNfs70onVbC7mhKCzNsxYx3WmG7ttlBinhGI,23659
 comfy_env/env/security.py,sha256=dNSitAnfBNVdvxgBBntYw33AJaCs_S1MHb7KJhAVYzM,8171
 comfy_env/env/platform/__init__.py,sha256=Nb5MPZIEeanSMEWwqU4p4bnEKTJn1tWcwobnhq9x9IY,614
 comfy_env/env/platform/base.py,sha256=iS0ptTTVjXRwPU4qWUdvHI7jteuzxGSjWr5BUQ7hGiU,2453
@@ -35,10 +35,10 @@ comfy_env/workers/base.py,sha256=ZILYXlvGCWuCZXmjKqfG8VeD19ihdYaASdlbasl2BMo,231
 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=4YSNPn7hALrvMVbkO4RkTeFTcc0lhfLMk5QTWjY4PHw,22134
-comfy_env/workers/venv.py,sha256=PmsVOu5i89tBYkGRupo2bjOLPBmk06q4GNUwDWsd9F8,32088
-comfy_env/wheel_sources.yml,sha256=M9Z3PPJrimV_B4tRRmZ8o_z6phZanJY_iEcjfMimtZw,8141
-comfy_env-0.0.44.dist-info/METADATA,sha256=6FS6i66IxVfnZafLY1Dyte4wc5dKM4CLt2pZho2_S18,7138
-comfy_env-0.0.44.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.0.44.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.0.44.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.0.44.dist-info/RECORD,,
+comfy_env/workers/venv.py,sha256=YXIjSo4JSq2m9W2sDXA6N0pBc8kv_MpxfOJ2YZjBkw4,38219
+comfy_env/wheel_sources.yml,sha256=K5dksy21YcT7QdFlVDkKF4Rv9ZCjHaWhQgoEhdSyAOI,8156
+comfy_env-0.0.45.dist-info/METADATA,sha256=sVpd0ratFmnZ9CG2fN3-NP0CDrEscDwmlGpOPLCq2wk,7138
+comfy_env-0.0.45.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.0.45.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.0.45.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.0.45.dist-info/RECORD,,