comfy-env 0.0.6__py3-none-any.whl → 0.0.9__py3-none-any.whl

comfy_env/__init__.py

@@ -40,7 +40,7 @@ This package provides:
 The @isolated decorator and WorkerBridge are still available.
 """
 
-__version__ = "0.0.6"
+__version__ = "0.0.8"
 
 from .env.config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq
 from .env.config_file import (

comfy_env/env/config.py

@@ -98,6 +98,10 @@ class IsolatedEnv:
     cuda: Optional[str] = None
     requirements: list[str] = field(default_factory=list)
     no_deps_requirements: list[str] = field(default_factory=list)  # Install with --no-deps
+    # Platform-specific requirements (merged at install time)
+    windows_requirements: list[str] = field(default_factory=list)
+    linux_requirements: list[str] = field(default_factory=list)
+    darwin_requirements: list[str] = field(default_factory=list)
     requirements_file: Optional[Path] = None
     wheel_sources: list[str] = field(default_factory=list)
     index_urls: list[str] = field(default_factory=list)

comfy_env/env/config_file.py

@@ -529,6 +529,30 @@ def _parse_single_env(name: str, env_data: Dict[str, Any], base_dir: Path) -> Is
     elif isinstance(packages_section, list):
         requirements = packages_section
 
+    # Parse platform-specific packages [envname.packages.windows], etc.
+    windows_reqs = []
+    linux_reqs = []
+    darwin_reqs = []
+
+    if isinstance(packages_section, dict):
+        win_section = packages_section.get("windows", {})
+        if isinstance(win_section, dict):
+            windows_reqs = win_section.get("requirements", [])
+        elif isinstance(win_section, list):
+            windows_reqs = win_section
+
+        linux_section = packages_section.get("linux", {})
+        if isinstance(linux_section, dict):
+            linux_reqs = linux_section.get("requirements", [])
+        elif isinstance(linux_section, list):
+            linux_reqs = linux_section
+
+        darwin_section = packages_section.get("darwin", {})
+        if isinstance(darwin_section, dict):
+            darwin_reqs = darwin_section.get("requirements", [])
+        elif isinstance(darwin_section, list):
+            darwin_reqs = darwin_section
+
     return IsolatedEnv(
         name=name,
         python=python,
@@ -536,6 +560,9 @@ def _parse_single_env(name: str, env_data: Dict[str, Any], base_dir: Path) -> Is
         pytorch_version=pytorch,
         requirements=requirements,
         no_deps_requirements=no_deps_requirements,
+        windows_requirements=windows_reqs,
+        linux_requirements=linux_reqs,
+        darwin_requirements=darwin_reqs,
     )
 
 

comfy_env/env/manager.py

@@ -263,13 +263,29 @@ class IsolatedEnvManager:
         """
         python_exe = self.get_python(env)
 
-        if not env.requirements and not env.requirements_file:
+        # Merge platform-specific requirements
+        if sys.platform == 'win32':
+            platform_reqs = env.windows_requirements
+            platform_name = 'Windows'
+        elif sys.platform == 'darwin':
+            platform_reqs = env.darwin_requirements
+            platform_name = 'macOS'
+        else:
+            platform_reqs = env.linux_requirements
+            platform_name = 'Linux'
+
+        all_requirements = list(env.requirements) + list(platform_reqs)
+
+        if platform_reqs:
+            self.log(f"Including {len(platform_reqs)} {platform_name}-specific packages")
+
+        if not all_requirements and not env.requirements_file:
             self.log("No requirements to install")
             return
 
         # Validate requirements for security
-        if env.requirements:
-            validate_dependencies(env.requirements)
+        if all_requirements:
+            validate_dependencies(all_requirements)
 
         # Validate wheel sources
         for wheel_source in env.wheel_sources:
@@ -311,11 +327,11 @@ class IsolatedEnvManager:
             self.log(f"Installing {len(env.no_deps_requirements)} CUDA packages")
             self._install_cuda_packages(env, pip_args)
 
-        # Install individual requirements
-        if env.requirements:
-            self.log(f"Installing {len(env.requirements)} packages")
+        # Install individual requirements (including platform-specific)
+        if all_requirements:
+            self.log(f"Installing {len(all_requirements)} packages")
             result = subprocess.run(
-                pip_args + env.requirements,
+                pip_args + all_requirements,
                 capture_output=True,
                 text=True,
             )
@@ -502,6 +518,57 @@ class IsolatedEnvManager:
         else:
             self.log("comfy-env installed")
 
+    def _setup_windows_deps(self, env: IsolatedEnv, env_dir: Path) -> None:
+        """
+        Set up Windows-specific dependencies (VC++ runtime, DLL paths).
+
+        This:
+        1. Installs msvc-runtime package (provides VC++ DLLs)
+        2. Sets up the Lib/x64/vc17/bin directory structure for opencv
+        """
+        python_exe = self.get_python(env)
+        uv = self._find_uv()
+
+        # Install msvc-runtime package to get VC++ DLLs
+        self.log("Installing VC++ runtime (msvc-runtime)...")
+        result = subprocess.run(
+            [str(uv), "pip", "install", "--python", str(python_exe), "msvc-runtime"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            self.log(f"Warning: Failed to install msvc-runtime: {result.stderr}")
+        else:
+            self.log("msvc-runtime installed")
+
+        # Set up opencv DLL paths (copies DLLs to Lib/x64/vc17/bin)
+        self.log("Setting up opencv DLL paths...")
+        success, msg = self.platform.setup_opencv_dll_paths(env_dir)
+        if success:
+            if msg:
+                self.log(f"  {msg}")
+        else:
+            self.log(f"Warning: {msg}")
+
+    def ensure_system_deps(self) -> bool:
+        """
+        Ensure system-level dependencies are installed (Windows only).
+
+        On Windows, this checks for Media Foundation and installs if missing.
+        Returns True if all deps are available, False otherwise.
+        """
+        if self.platform.name != 'windows':
+            return True
+
+        # Check and install Media Foundation if needed
+        success, error = self.platform.ensure_media_foundation(self.log)
+        if not success:
+            self.log(f"WARNING: {error}")
+            self.log("Some packages (like opencv) may not work correctly.")
+            return False
+
+        return True
+
     def setup(
         self,
         env: IsolatedEnv,
@@ -525,6 +592,9 @@ class IsolatedEnvManager:
         self.log(f"Setting up isolated environment: {env.name}")
         self.log("=" * 50)
 
+        # Ensure system-level deps (Media Foundation on Windows)
+        self.ensure_system_deps()
+
         # Check if already ready
         if self.is_ready(env, verify_packages):
             self.log("Environment already ready, skipping setup")
@@ -543,12 +613,9 @@ class IsolatedEnvManager:
         # Install other requirements
         self.install_requirements(env)
 
-        # Windows: Bundle VC++ DLLs
+        # Windows: Install VC++ runtime and set up DLL paths
         if self.platform.name == 'windows':
-            self.log("Bundling VC++ DLLs...")
-            success, error = self.platform.bundle_vc_dlls_to_env(env_dir)
-            if not success:
-                self.log(f"Warning: {error}")
+            self._setup_windows_deps(env, env_dir)
 
         # Verify installation
         if verify_packages:

comfy_env/env/platform/windows.py

@@ -5,6 +5,7 @@ Windows platform provider implementation.
 import os
 import stat
 import shutil
+import subprocess
 import sys
 import time
 from pathlib import Path
@@ -193,3 +194,184 @@ class WindowsPlatformProvider(PlatformProvider):
                     raise
 
         return False
+
+    # =========================================================================
+    # Media Foundation Detection and Installation
+    # =========================================================================
+
+    def check_media_foundation(self) -> bool:
+        """
+        Check if Media Foundation DLLs exist on the system.
+
+        These are required by packages like opencv-python for video/media support.
+        Missing on Windows N/KN editions and some Windows Server installations.
+        """
+        system_root = os.environ.get('SystemRoot', r'C:\Windows')
+        mf_dlls = ['MFPlat.dll', 'MF.dll', 'MFReadWrite.dll']
+
+        for dll in mf_dlls:
+            dll_path = Path(system_root) / 'System32' / dll
+            if not dll_path.exists():
+                return False
+        return True
+
+    def install_media_foundation(self, log_callback=None) -> Tuple[bool, Optional[str]]:
+        """
+        Install Media Foundation via DISM.
+
+        Requires administrator privileges. Will trigger UAC prompt if needed.
+
+        Returns:
+            Tuple of (success, error_message)
+        """
+        log = log_callback or print
+
+        if self.check_media_foundation():
+            return (True, None)
+
+        log("Media Foundation not found. Installing via DISM...")
+        log("(This requires administrator privileges - a UAC prompt may appear)")
+
+        # DISM command to install Media Feature Pack
+        dism_cmd = [
+            "DISM.exe", "/Online", "/Add-Capability",
+            "/CapabilityName:Media.MediaFeaturePack~~~~0.0.1.0"
+        ]
+
+        try:
+            # First try without elevation (in case already running as admin)
+            result = subprocess.run(
+                dism_cmd,
+                capture_output=True,
+                text=True,
+                timeout=300  # 5 minute timeout for installation
+            )
+
+            if result.returncode == 0:
+                log("Media Foundation installed successfully!")
+                return (True, None)
+
+            # Check if we need elevation
+            if "administrator" in result.stderr.lower() or result.returncode == 740:
+                log("Requesting administrator privileges...")
+                return self._install_media_foundation_elevated(log)
+
+            # Other error
+            return (False,
+                f"DISM failed with code {result.returncode}:\n{result.stderr}\n\n"
+                f"Please install Media Foundation manually:\n"
+                f"  1. Open Settings > Apps > Optional Features\n"
+                f"  2. Click 'Add a feature'\n"
+                f"  3. Search for 'Media Feature Pack' and install it\n"
+                f"  4. Restart your computer")
+
+        except subprocess.TimeoutExpired:
+            return (False, "DISM timed out. Please try installing manually via Settings.")
+        except FileNotFoundError:
+            return (False, "DISM.exe not found. Please install Media Feature Pack manually via Settings.")
+        except Exception as e:
+            return (False, f"Error running DISM: {e}")
+
+    def _install_media_foundation_elevated(self, log_callback=None) -> Tuple[bool, Optional[str]]:
+        """
+        Install Media Foundation with UAC elevation.
+
+        Uses PowerShell Start-Process -Verb RunAs to trigger UAC prompt.
+        """
+        log = log_callback or print
+
+        # Create a PowerShell script that runs DISM elevated
+        ps_script = '''
+        $result = Start-Process -FilePath "DISM.exe" -ArgumentList "/Online", "/Add-Capability", "/CapabilityName:Media.MediaFeaturePack~~~~0.0.1.0" -Verb RunAs -Wait -PassThru
+        exit $result.ExitCode
+        '''
+
+        try:
+            result = subprocess.run(
+                ["powershell", "-ExecutionPolicy", "Bypass", "-Command", ps_script],
+                capture_output=True,
+                text=True,
+                timeout=300
+            )
+
+            if result.returncode == 0:
+                # Verify installation
+                if self.check_media_foundation():
+                    log("Media Foundation installed successfully!")
+                    return (True, None)
+                else:
+                    return (False,
+                        "Installation completed but Media Foundation DLLs not found.\n"
+                        "A system restart may be required.")
+            else:
+                return (False,
+                    f"Installation failed or was cancelled.\n"
+                    f"Please install Media Feature Pack manually:\n"
+                    f"  Settings > Apps > Optional Features > Add a feature > Media Feature Pack")
+
+        except subprocess.TimeoutExpired:
+            return (False, "Installation timed out. Please try installing manually via Settings.")
+        except Exception as e:
+            return (False, f"Error during elevated installation: {e}")
+
+    def ensure_media_foundation(self, log_callback=None) -> Tuple[bool, Optional[str]]:
+        """
+        Ensure Media Foundation is installed, installing if necessary.
+
+        This is the main entry point for MF dependency checking.
+        """
+        if self.check_media_foundation():
+            return (True, None)
+
+        return self.install_media_foundation(log_callback)
+
+    # =========================================================================
+    # OpenCV DLL Directory Setup
+    # =========================================================================
+
+    def setup_opencv_dll_paths(self, env_dir: Path) -> Tuple[bool, Optional[str]]:
+        """
+        Set up the DLL directory structure that opencv-python expects.
+
+        OpenCV's config.py expects VC++ DLLs at:
+          {site-packages}/cv2/../../x64/vc17/bin
+        Which resolves to:
+          {env_dir}/Lib/x64/vc17/bin
+
+        This copies the VC++ DLLs to that location.
+        """
+        # Target directory that opencv expects
+        target_dir = env_dir / "Lib" / "x64" / "vc17" / "bin"
+
+        # Source: DLLs in Scripts or base env dir (from msvc-runtime package)
+        scripts_dir = env_dir / "Scripts"
+
+        vc_dlls = [
+            'vcruntime140.dll', 'vcruntime140_1.dll', 'vcruntime140_threads.dll',
+            'msvcp140.dll', 'msvcp140_1.dll', 'msvcp140_2.dll',
+            'msvcp140_atomic_wait.dll', 'msvcp140_codecvt_ids.dll',
+            'concrt140.dll', 'vcomp140.dll', 'vcamp140.dll', 'vccorlib140.dll'
+        ]
+
+        try:
+            target_dir.mkdir(parents=True, exist_ok=True)
+
+            copied = 0
+            for dll_name in vc_dlls:
+                # Try Scripts first, then env root
+                for source_dir in [scripts_dir, env_dir]:
+                    source = source_dir / dll_name
+                    if source.exists():
+                        target = target_dir / dll_name
+                        if not target.exists():
+                            shutil.copy2(source, target)
+                            copied += 1
+                        break
+
+            if copied > 0:
+                return (True, f"Copied {copied} VC++ DLLs to opencv path")
+            else:
+                return (True, "VC++ DLLs already in place or not found in venv")
+
+        except Exception as e:
+            return (False, f"Failed to set up opencv DLL paths: {e}")

comfy_env/workers/venv.py

@@ -421,6 +421,19 @@ import json
 import traceback
 from types import SimpleNamespace
 
+# 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")
+    if _host_python_dir and hasattr(os, "add_dll_directory"):
+        try:
+            os.add_dll_directory(_host_python_dir)
+            # Also add DLLs subdirectory if it exists
+            _dlls_dir = os.path.join(_host_python_dir, "DLLs")
+            if os.path.isdir(_dlls_dir):
+                os.add_dll_directory(_dlls_dir)
+        except Exception:
+            pass
+
 def _deserialize_isolated_objects(obj):
     """Reconstruct objects serialized with __isolated_object__ marker."""
     if isinstance(obj, dict):
@@ -437,6 +450,10 @@ def _deserialize_isolated_objects(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:
@@ -451,9 +468,9 @@ def main():
     # Import torch after path setup
     import torch
 
-    # Signal ready
-    sys.stdout.write(json.dumps({"status": "ready"}) + "\\n")
-    sys.stdout.flush()
+    # Signal ready (use _ipc_out, not stdout)
+    _ipc_out.write(json.dumps({"status": "ready"}) + "\\n")
+    _ipc_out.flush()
 
     # Process requests
     while True:
@@ -504,16 +521,16 @@ def main():
             if outputs_path:
                 torch.save(result, outputs_path)
 
-            sys.stdout.write(json.dumps({"status": "ok"}) + "\\n")
-            sys.stdout.flush()
+            _ipc_out.write(json.dumps({"status": "ok"}) + "\\n")
+            _ipc_out.flush()
 
         except Exception as e:
-            sys.stdout.write(json.dumps({
+            _ipc_out.write(json.dumps({
                 "status": "error",
                 "error": str(e),
                 "traceback": traceback.format_exc(),
             }) + "\\n")
-            sys.stdout.flush()
+            _ipc_out.flush()
 
 if __name__ == "__main__":
     main()
@@ -598,6 +615,11 @@ class PersistentVenvWorker(Worker):
         env.update(self.extra_env)
         env["COMFYUI_ISOLATION_WORKER"] = "1"
 
+        # On Windows, pass host Python directory so worker can add it via os.add_dll_directory()
+        # This fixes "DLL load failed" errors for packages like opencv-python-headless
+        if sys.platform == "win32":
+            env["COMFYUI_HOST_PYTHON_DIR"] = str(Path(sys.executable).parent)
+
         # Find ComfyUI base and set env var for folder_paths stub
         comfyui_base = self._find_comfyui_base()
         if comfyui_base:
@@ -620,6 +642,18 @@ class PersistentVenvWorker(Worker):
             text=True,  # Text mode for JSON
         )
 
+        # Start stderr forwarding thread to show worker output in real-time
+        def forward_stderr():
+            try:
+                for line in self._process.stderr:
+                    # Forward to main process stderr (visible in console)
+                    sys.stderr.write(f"  {line}")
+                    sys.stderr.flush()
+            except:
+                pass
+        self._stderr_thread = threading.Thread(target=forward_stderr, daemon=True)
+        self._stderr_thread.start()
+
         # Send config
         config = {"sys_paths": all_sys_path}
         self._process.stdin.write(json.dumps(config) + "\n")

{comfy_env-0.0.6.dist-info → comfy_env-0.0.9.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-comfy_env/__init__.py,sha256=en7nqZ2zKYmItKtXXlgudZyE9V-X6oR43uBmv93E2d8,4249
+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
@@ -7,16 +7,16 @@ 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/config.py,sha256=R8JyE5iQLHKgnxXOGA8SAI7iu2eYSfXn-MsaqHoU2_A,5667
+comfy_env/env/config_file.py,sha256=2sTeBUqdDYPwQfUO-3Mu2zTsgxQ4IhllRxEd2a4pgPg,20593
 comfy_env/env/detection.py,sha256=Co8BJmTRCq1ZHDsm6832jF87za0GRAhH7zF04-5QwcE,4949
-comfy_env/env/manager.py,sha256=nex-V0NMFQuaf0PhSMksqkTbxONalE852RnYMTorzLM,22237
+comfy_env/env/manager.py,sha256=hGaK9C_nRwfHthowgFv2rPhhpfAMDJhxPEdQFFv6BbI,24770
 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=1R343532UW1QD7TTtPbjTttPmbauXuFUtbpIN6xyJPE,7383
+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
@@ -31,9 +31,9 @@ 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=DsfxE3LBAWEuGtk-p-YL0UhVQ7VDh73KT_TFRxYN4-Q,12563
-comfy_env/workers/venv.py,sha256=wXHR1hfTEVVneKVVV_yF4O5FbjgEd2qMkRdJz6AOKy8,30002
-comfy_env-0.0.6.dist-info/METADATA,sha256=yiZviGyQYEMnt1Yif_sYqWbs40gUiqa3Dd25KDFWVvI,5371
-comfy_env-0.0.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.0.6.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.0.6.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.0.6.dist-info/RECORD,,
+comfy_env/workers/venv.py,sha256=_ekHfZPqBIPY08DjqiXm6cTBQH4DrbxRWR3AAv3mit8,31589
+comfy_env-0.0.9.dist-info/METADATA,sha256=HwKjPaZyiGGsJ47w8nempK8MokAu1YbWS1ZqwSCXS_4,5371
+comfy_env-0.0.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.0.9.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.0.9.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.0.9.dist-info/RECORD,,