comfy-env 0.0.8__py3-none-any.whl → 0.0.16__py3-none-any.whl

comfy_env-0.0.16.dist-info/RECORD

@@ -0,0 +1,40 @@
+comfy_env/__init__.py,sha256=76gIAh7qFff_v_bAolXVzuWzcgvD3bp-yQGCNzba_Iw,3287
+comfy_env/cli.py,sha256=q4y_tlPyqKMZhge7XeO9VdbFVZ4dl9LZsgnnTVQYXD4,15979
+comfy_env/decorator.py,sha256=daFR5aLzshkmo5sRKhSGPcTUgIUWml7Gs6A1bfnDuyc,15718
+comfy_env/errors.py,sha256=8hN8NDlo8oBUdapc-eT3ZluigI5VBzfqsSBvQdfWlz4,9943
+comfy_env/install.py,sha256=uk7mtmoDrcCs6MCfz-5WuyYtgd9JFaByarBWgSUc7Dk,20518
+comfy_env/registry.py,sha256=uFCtGmWYvwGCqObXgzmArX7o5JsFNsHXxayofk3m6no,2569
+comfy_env/resolver.py,sha256=l-AnmCE1puG6CvdpDB-KrsfG_cn_3uO2DryYizUnG_4,12474
+comfy_env/tools.py,sha256=mFNB_uq64ON5hlreH_0wTLONahDo3pBHxhQYTcTHxXE,6554
+comfy_env/env/__init__.py,sha256=imQdoQEQvrRT-QDtyNpFlkVbm2fBzgACdpQwRPd09fI,1157
+comfy_env/env/config.py,sha256=6KZPhRiW8ShhuDnX-e6_yjZHMdO_xBm02w00Q3NBJXM,5980
+comfy_env/env/config_file.py,sha256=tJ9xfmf2RghzK6PUxwTrhpvqV_5pecjC6IYYBoZ0U58,21890
+comfy_env/env/cuda_gpu_detection.py,sha256=YLuXUdWg6FeKdNyLlQAHPlveg4rTenXJ2VbeAaEi9QE,9755
+comfy_env/env/manager.py,sha256=bbV1MpURNGuBJ1sSWg_2oSU0J-dW-FhBCuHHHQxgrSM,24785
+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
+comfy_env/env/platform/darwin.py,sha256=HK3VkLT6DfesAnIXwx2IaUFHTBclF0xTQnC7azWY6Kc,1552
+comfy_env/env/platform/linux.py,sha256=xLp8FEbFqZLQrzIZBI9z3C4g23Ab1ASTHLsXDzsdCoA,2062
+comfy_env/env/platform/windows.py,sha256=FCOCgpzGzorY9-HueMlJUR8DxM2eH-cj9iZk6K026Is,10891
+comfy_env/ipc/__init__.py,sha256=pTjgJn5YJxLXmEvuKh3lkCEJQs-6W6_F01jfkFMUi0c,1375
+comfy_env/ipc/bridge.py,sha256=zcyN3xzV4WWBrBFNwCniPBR58dLCg46-k9TtyW5U000,16437
+comfy_env/ipc/protocol.py,sha256=gfWe5yEDUn4QWhcdWFcxn40GqxlW1Uf23j0edOzPPng,7951
+comfy_env/ipc/tensor.py,sha256=DyU28GymKkLPVwzZyKdm2Av222hdaycMgv3KdL5mtO0,12009
+comfy_env/ipc/torch_bridge.py,sha256=WzdwDJa3N_1fEl9OeZxikvMbwryO5P63o0WmEDpS18A,13206
+comfy_env/ipc/transport.py,sha256=XQlRcfQsd4nd909KIYnZKvsS3ksGpGjyVucn8jvmLIU,9698
+comfy_env/ipc/worker.py,sha256=oxTLF9xXrl8CRx_JVNBdkxZh35NuzfkdxhaUtUuXogs,6661
+comfy_env/stubs/__init__.py,sha256=jMeWEKY30y8QqYX9AUyuZbmm607erQTc4N7YaDoAH00,38
+comfy_env/stubs/folder_paths.py,sha256=Pv30qHeHBmfK5icIpmXnTGvZkRMJHDrTh9mQ1WMclLg,1713
+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=DsfxE3LBAWEuGtk-p-YL0UhVQ7VDh73KT_TFRxYN4-Q,12563
+comfy_env/workers/venv.py,sha256=_ekHfZPqBIPY08DjqiXm6cTBQH4DrbxRWR3AAv3mit8,31589
+comfy_env/wheel_sources.yml,sha256=ubVuQllCQGkZhLNQaG54divCwn0zLzYg4turzhnIZQ8,7150
+comfy_env-0.0.16.dist-info/METADATA,sha256=jj04Wmh8ojLkTKSOwyRug1kSWT4SrpsY5PKfgbuq0NE,5399
+comfy_env-0.0.16.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.0.16.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.0.16.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.0.16.dist-info/RECORD,,

comfy_env/env/detection.py

@@ -1,176 +0,0 @@
-"""
-GPU detection for automatic CUDA version selection.
-
-Detects Blackwell GPUs (RTX 50xx, B100, B200) which require CUDA 12.8,
-vs older GPUs which use CUDA 12.4.
-
-This runs BEFORE PyTorch is installed, so we use nvidia-smi directly.
-"""
-
-import subprocess
-from typing import List, Dict, Optional
-
-
-def detect_gpu_info() -> List[Dict[str, str]]:
-    """
-    Detect GPU name and compute capability using nvidia-smi.
-
-    Returns:
-        List of dicts with 'name' and 'compute_cap' keys.
-        Empty list if detection fails.
-    """
-    try:
-        result = subprocess.run(
-            ["nvidia-smi", "--query-gpu=name,compute_cap", "--format=csv,noheader"],
-            capture_output=True,
-            text=True,
-            timeout=10
-        )
-        if result.returncode == 0:
-            gpus = []
-            for line in result.stdout.strip().split('\n'):
-                if not line.strip():
-                    continue
-                parts = [p.strip() for p in line.split(',')]
-                name = parts[0] if parts else "Unknown"
-                cc = parts[1] if len(parts) > 1 else "0.0"
-                gpus.append({"name": name, "compute_cap": cc})
-            return gpus
-    except FileNotFoundError:
-        # nvidia-smi not found - no NVIDIA GPU or driver not installed
-        pass
-    except subprocess.TimeoutExpired:
-        pass
-    except Exception:
-        pass
-    return []
-
-
-def is_blackwell_gpu(name: str, compute_cap: str) -> bool:
-    """
-    Check if a GPU is Blackwell architecture.
-
-    Args:
-        name: GPU name from nvidia-smi
-        compute_cap: Compute capability string (e.g., "8.9", "12.0")
-
-    Returns:
-        True if Blackwell (requires CUDA 12.8)
-    """
-    name_upper = name.upper()
-
-    # Check by name patterns
-    blackwell_patterns = [
-        "RTX 50",      # RTX 5090, 5080, 5070, etc.
-        "RTX50",       # Without space
-        "B100",        # Datacenter Blackwell
-        "B200",        # Datacenter Blackwell
-        "GB202",       # Blackwell die
-        "GB203",
-        "GB205",
-        "GB206",
-        "GB207",
-    ]
-
-    if any(pattern in name_upper for pattern in blackwell_patterns):
-        return True
-
-    # Check by compute capability (10.0+ = Blackwell)
-    try:
-        cc = float(compute_cap)
-        if cc >= 10.0:
-            return True
-    except (ValueError, TypeError):
-        pass
-
-    return False
-
-
-def needs_cuda_128() -> bool:
-    """
-    Check if any detected GPU requires CUDA 12.8.
-
-    Returns:
-        True if Blackwell GPU detected, False otherwise.
-    """
-    gpus = detect_gpu_info()
-
-    for gpu in gpus:
-        if is_blackwell_gpu(gpu["name"], gpu["compute_cap"]):
-            return True
-
-    return False
-
-
-def is_legacy_gpu(compute_cap: str) -> bool:
-    """
-    Check if GPU is Pascal or older (requires legacy CUDA/PyTorch).
-
-    Args:
-        compute_cap: Compute capability string (e.g., "6.1", "7.5")
-
-    Returns:
-        True if Pascal or older (compute < 7.5)
-    """
-    try:
-        cc = float(compute_cap)
-        return cc < 7.5  # Turing starts at 7.5
-    except (ValueError, TypeError):
-        return False
-
-
-def detect_cuda_version() -> Optional[str]:
-    """
-    Get recommended CUDA version based on detected GPU.
-
-    Returns:
-        "12.4" for Pascal or older (compute < 7.5),
-        "12.8" for Turing or newer (compute >= 7.5),
-        None if no GPU detected.
-
-    GPU Architecture Reference:
-        - Pascal (GTX 10xx, P100): compute 6.0-6.1 → CUDA 12.4
-        - Turing (RTX 20xx, T4): compute 7.5 → CUDA 12.8
-        - Ampere (RTX 30xx, A100): compute 8.0-8.6 → CUDA 12.8
-        - Ada (RTX 40xx, L40): compute 8.9 → CUDA 12.8
-        - Hopper (H100): compute 9.0 → CUDA 12.8
-        - Blackwell (RTX 50xx, B100/B200): compute 10.0+ → CUDA 12.8
-    """
-    gpus = detect_gpu_info()
-    if not gpus:
-        return None
-
-    # Check if any GPU is legacy (Pascal or older)
-    for gpu in gpus:
-        if is_legacy_gpu(gpu.get("compute_cap", "0.0")):
-            return "12.4"
-
-    # Turing or newer - use modern stack
-    return "12.8"
-
-
-def get_gpu_summary() -> str:
-    """
-    Get a human-readable summary of detected GPUs.
-
-    Returns:
-        Summary string for logging.
-    """
-    gpus = detect_gpu_info()
-
-    if not gpus:
-        return "No NVIDIA GPU detected"
-
-    lines = []
-    for i, gpu in enumerate(gpus):
-        cc = gpu.get("compute_cap", "0.0")
-        is_legacy = is_legacy_gpu(cc)
-        if is_legacy:
-            tag = " [Pascal - CUDA 12.4]"
-        elif is_blackwell_gpu(gpu["name"], cc):
-            tag = " [Blackwell - CUDA 12.8]"
-        else:
-            tag = " [CUDA 12.8]"
-        lines.append(f"  GPU {i}: {gpu['name']} (sm_{cc.replace('.', '')}){tag}")
-
-    return "\n".join(lines)

comfy_env/runner.py

@@ -1,273 +0,0 @@
-"""
-Generic runner for isolated subprocess execution.
-
-This module is the entry point for subprocess execution. The runner handles
-requests for ANY @isolated class in the environment, importing classes on demand.
-
-Usage (Unix Domain Socket - recommended):
-    python -m comfy_env.runner \
-        --node-dir /path/to/ComfyUI-SAM3DObjects/nodes \
-        --comfyui-base /path/to/ComfyUI \
-        --import-paths ".,../vendor" \
-        --socket /tmp/comfyui-isolation-myenv-12345.sock
-
-Usage (Legacy stdin/stdout):
-    python -m comfy_env.runner \
-        --node-dir /path/to/ComfyUI-SAM3DObjects/nodes \
-        --comfyui-base /path/to/ComfyUI \
-        --import-paths ".,../vendor"
-
-The runner:
-1. Sets COMFYUI_ISOLATION_WORKER=1 (so @isolated decorator becomes no-op)
-2. Adds paths to sys.path
-3. Connects to Unix Domain Socket (or uses stdin/stdout)
-4. Dynamically imports classes as needed (cached)
-5. Calls methods and returns responses
-"""
-
-import os
-import sys
-import json
-import argparse
-import traceback
-import warnings
-import logging
-import importlib
-from typing import Any, Dict, Optional
-
-# Suppress warnings that could interfere with JSON IPC
-warnings.filterwarnings("ignore")
-os.environ.setdefault("TF_CPP_MIN_LOG_LEVEL", "3")
-logging.disable(logging.WARNING)
-
-# Mark that we're in worker mode - this makes @isolated decorator a no-op
-os.environ["COMFYUI_ISOLATION_WORKER"] = "1"
-
-
-def setup_paths(node_dir: str, comfyui_base: Optional[str], import_paths: Optional[str]):
-    """Setup sys.path for imports."""
-    from pathlib import Path
-
-    node_path = Path(node_dir)
-
-    # Set COMFYUI_BASE env var for stubs to use
-    if comfyui_base:
-        os.environ["COMFYUI_BASE"] = comfyui_base
-
-    # Add comfyui-isolation stubs directory (provides folder_paths, etc.)
-    stubs_dir = Path(__file__).parent / "stubs"
-    sys.path.insert(0, str(stubs_dir))
-
-    # Add import paths
-    if import_paths:
-        for p in import_paths.split(","):
-            p = p.strip()
-            if p:
-                full_path = node_path / p
-                sys.path.insert(0, str(full_path))
-
-    # Add node_dir itself
-    sys.path.insert(0, str(node_path))
-
-
-def serialize_result(obj: Any) -> Any:
-    """Serialize result for JSON transport."""
-    from comfy_env.ipc.protocol import encode_object
-    return encode_object(obj)
-
-
-def deserialize_arg(obj: Any) -> Any:
-    """Deserialize argument from JSON transport."""
-    from comfy_env.ipc.protocol import decode_object
-    return decode_object(obj)
-
-
-# Cache for imported classes and instances
-_class_cache: Dict[str, type] = {}
-_instance_cache: Dict[str, object] = {}
-
-
-def get_instance(module_name: str, class_name: str) -> object:
-    """Get or create an instance of a class."""
-    cache_key = f"{module_name}.{class_name}"
-
-    if cache_key not in _instance_cache:
-        # Import the class if not cached
-        if cache_key not in _class_cache:
-            print(f"[Runner] Importing {class_name} from {module_name}...", file=sys.stderr)
-            module = importlib.import_module(module_name)
-            cls = getattr(module, class_name)
-            _class_cache[cache_key] = cls
-
-        # Create instance
-        cls = _class_cache[cache_key]
-        _instance_cache[cache_key] = cls()
-        print(f"[Runner] Created instance of {class_name}", file=sys.stderr)
-
-    return _instance_cache[cache_key]
-
-
-def run_worker(
-    node_dir: str,
-    comfyui_base: Optional[str],
-    import_paths: Optional[str],
-    socket_path: Optional[str] = None,
-):
-    """
-    Main worker loop - handles JSON-RPC requests via transport.
-
-    Args:
-        node_dir: Path to node package directory
-        comfyui_base: Path to ComfyUI base directory
-        import_paths: Comma-separated import paths
-        socket_path: Unix domain socket path (if None, uses stdin/stdout)
-    """
-    from comfy_env.ipc.transport import UnixSocketTransport, StdioTransport
-
-    # Setup paths first
-    setup_paths(node_dir, comfyui_base, import_paths)
-
-    # Create transport
-    if socket_path:
-        # Unix Domain Socket transport (recommended)
-        print(f"[Runner] Connecting to socket: {socket_path}", file=sys.stderr)
-        transport = UnixSocketTransport.connect(socket_path)
-        use_uds = True
-    else:
-        # Legacy stdin/stdout transport
-        print("[Runner] Using stdin/stdout transport", file=sys.stderr)
-        transport = StdioTransport()
-        use_uds = False
-
-    try:
-        # Send ready signal
-        transport.send({"status": "ready"})
-
-        # Main loop - read requests, execute, respond
-        while True:
-            response = {"jsonrpc": "2.0", "id": None}
-
-            try:
-                request = transport.recv()
-                response["id"] = request.get("id")
-
-                method_name = request.get("method")
-                params = request.get("params", {})
-
-                if method_name == "shutdown":
-                    # Clean shutdown
-                    response["result"] = {"status": "shutdown"}
-                    transport.send(response)
-                    break
-
-                # Get module/class from request
-                module_name = request.get("module")
-                class_name = request.get("class")
-
-                if not module_name or not class_name:
-                    response["error"] = {
-                        "code": -32602,
-                        "message": "Missing 'module' or 'class' in request",
-                    }
-                    transport.send(response)
-                    continue
-
-                # Get or create instance
-                try:
-                    instance = get_instance(module_name, class_name)
-                except Exception as e:
-                    response["error"] = {
-                        "code": -32000,
-                        "message": f"Failed to import {module_name}.{class_name}: {e}",
-                        "data": {"traceback": traceback.format_exc()}
-                    }
-                    transport.send(response)
-                    continue
-
-                # Get the method
-                method = getattr(instance, method_name, None)
-                if method is None:
-                    response["error"] = {
-                        "code": -32601,
-                        "message": f"Method not found: {method_name}",
-                    }
-                    transport.send(response)
-                    continue
-
-                # Deserialize arguments
-                deserialized_params = {}
-                for key, value in params.items():
-                    deserialized_params[key] = deserialize_arg(value)
-
-                # For legacy stdio transport, redirect stdout to stderr during execution
-                # This prevents print() in node code from corrupting JSON protocol
-                # (UDS transport doesn't need this since it uses a separate socket)
-                if not use_uds:
-                    original_stdout = sys.stdout
-                    sys.stdout = sys.stderr
-
-                    # Also redirect at file descriptor level for C libraries
-                    stdout_fd = original_stdout.fileno()
-                    stderr_fd = sys.stderr.fileno()
-                    stdout_fd_copy = os.dup(stdout_fd)
-                    os.dup2(stderr_fd, stdout_fd)
-
-                # Call the method
-                print(f"[Runner] Calling {class_name}.{method_name}...", file=sys.stderr)
-                try:
-                    result = method(**deserialized_params)
-                finally:
-                    if not use_uds:
-                        # Restore file descriptor first, then Python stdout
-                        os.dup2(stdout_fd_copy, stdout_fd)
-                        os.close(stdout_fd_copy)
-                        sys.stdout = original_stdout
-
-                # Serialize result
-                serialized_result = serialize_result(result)
-                response["result"] = serialized_result
-
-                print(f"[Runner] {class_name}.{method_name} completed", file=sys.stderr)
-
-            except ConnectionError as e:
-                # Socket closed - normal shutdown
-                print(f"[Runner] Connection closed: {e}", file=sys.stderr)
-                break
-            except Exception as e:
-                tb = traceback.format_exc()
-                print(f"[Runner] Error: {e}", file=sys.stderr)
-                print(tb, file=sys.stderr)
-                response["error"] = {
-                    "code": -32000,
-                    "message": str(e),
-                    "data": {"traceback": tb}
-                }
-
-            try:
-                transport.send(response)
-            except ConnectionError:
-                break
-
-    finally:
-        transport.close()
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Isolated node runner")
-    parser.add_argument("--node-dir", required=True, help="Node package directory")
-    parser.add_argument("--comfyui-base", help="ComfyUI base directory")
-    parser.add_argument("--import-paths", help="Comma-separated import paths")
-    parser.add_argument("--socket", help="Unix domain socket path (if not provided, uses stdin/stdout)")
-
-    args = parser.parse_args()
-
-    run_worker(
-        node_dir=args.node_dir,
-        comfyui_base=args.comfyui_base,
-        import_paths=args.import_paths,
-        socket_path=args.socket,
-    )
-
-
-if __name__ == "__main__":
-    main()

comfy_env-0.0.8.dist-info/RECORD

@@ -1,39 +0,0 @@
-comfy_env/__init__.py,sha256=U5XtB2UeXZi8JPBhlh0XjQprLsAuVslPoJNWOSvCFhs,4249
-comfy_env/cli.py,sha256=9GvQYrXlJRl0ZaCuFHvRtVxWQ34Axd5Brgu5FWRONp4,11424
-comfy_env/decorator.py,sha256=daFR5aLzshkmo5sRKhSGPcTUgIUWml7Gs6A1bfnDuyc,15718
-comfy_env/errors.py,sha256=egeyXY-j7KpxyA0s67TcJLEfJX23LCAD3v1P4FgQIGE,10917
-comfy_env/install.py,sha256=JaatBM5PyY4Ua6E2HgkLAlFZ2TSEjlI-lAwJ-Hl7wU8,18876
-comfy_env/registry.py,sha256=iZprw2iIAJl-Vvotsf_B_PofzqE-6IiVfNPBHYUYg6g,11577
-comfy_env/resolver.py,sha256=xz7GPlxy02iwwpocIzzbdGnrwnSpi-D5IzpL8SQSgvI,12893
-comfy_env/runner.py,sha256=0YUqzK93u--7pKV6_yVC564AJE9rS3y81t5ZhQi2t4Y,9696
-comfy_env/env/__init__.py,sha256=sybOBrxJCfL4Xry9NNd5xwn9hXIHudXlXDa7SpJkPCE,811
-comfy_env/env/config.py,sha256=fL2P0ScoioPktZEHQnoo1dy-VB5intJEYLHm5fuOmF8,5406
-comfy_env/env/config_file.py,sha256=QLf3WPCqx46v1kVzM4jV_QAz919zmkk0_FRtLD3jO8s,19507
-comfy_env/env/detection.py,sha256=Co8BJmTRCq1ZHDsm6832jF87za0GRAhH7zF04-5QwcE,4949
-comfy_env/env/manager.py,sha256=ysIVlpxRD5x-5X47ESmfly2Vz6jv-9yA6863szHf7-8,24131
-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
-comfy_env/env/platform/darwin.py,sha256=HK3VkLT6DfesAnIXwx2IaUFHTBclF0xTQnC7azWY6Kc,1552
-comfy_env/env/platform/linux.py,sha256=xLp8FEbFqZLQrzIZBI9z3C4g23Ab1ASTHLsXDzsdCoA,2062
-comfy_env/env/platform/windows.py,sha256=nD1-bKU2rGmEJlS-cc5yWXMSA51YQtVupn-lQEO5UYA,14840
-comfy_env/ipc/__init__.py,sha256=pTjgJn5YJxLXmEvuKh3lkCEJQs-6W6_F01jfkFMUi0c,1375
-comfy_env/ipc/bridge.py,sha256=kEy__kco8FVQNj5MyadF5k00YEivcGmifAJAOfr643U,17645
-comfy_env/ipc/protocol.py,sha256=gfWe5yEDUn4QWhcdWFcxn40GqxlW1Uf23j0edOzPPng,7951
-comfy_env/ipc/tensor.py,sha256=DyU28GymKkLPVwzZyKdm2Av222hdaycMgv3KdL5mtO0,12009
-comfy_env/ipc/torch_bridge.py,sha256=WzdwDJa3N_1fEl9OeZxikvMbwryO5P63o0WmEDpS18A,13206
-comfy_env/ipc/transport.py,sha256=XQlRcfQsd4nd909KIYnZKvsS3ksGpGjyVucn8jvmLIU,9698
-comfy_env/ipc/worker.py,sha256=oxTLF9xXrl8CRx_JVNBdkxZh35NuzfkdxhaUtUuXogs,6661
-comfy_env/stubs/__init__.py,sha256=jMeWEKY30y8QqYX9AUyuZbmm607erQTc4N7YaDoAH00,38
-comfy_env/stubs/folder_paths.py,sha256=KEH9ntMH6HOgE595G5dBL9kSTEUvf_shYtQKIyiiDbk,1586
-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=DsfxE3LBAWEuGtk-p-YL0UhVQ7VDh73KT_TFRxYN4-Q,12563
-comfy_env/workers/venv.py,sha256=_ekHfZPqBIPY08DjqiXm6cTBQH4DrbxRWR3AAv3mit8,31589
-comfy_env-0.0.8.dist-info/METADATA,sha256=mir9pZymbCPcnI6yc1YrjxyMMnX3qm3pUR7NILB5iCE,5371
-comfy_env-0.0.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.0.8.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.0.8.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.0.8.dist-info/RECORD,,