comfy-env 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

comfy_env/pixi/platform/windows.py

@@ -1,284 +0,0 @@
-"""
-Windows platform provider implementation.
-"""
-
-import os
-import stat
-import shutil
-import subprocess
-import sys
-import time
-from pathlib import Path
-from typing import Dict, Optional, Tuple
-
-from .base import PlatformProvider, PlatformPaths
-
-
-class WindowsPlatformProvider(PlatformProvider):
-    """Platform provider for Windows systems."""
-
-    @property
-    def name(self) -> str:
-        return 'windows'
-
-    @property
-    def executable_suffix(self) -> str:
-        return '.exe'
-
-    @property
-    def shared_lib_extension(self) -> str:
-        return '.dll'
-
-    def get_env_paths(self, env_dir: Path, python_version: str = "3.10") -> PlatformPaths:
-        return PlatformPaths(
-            python=env_dir / "Scripts" / "python.exe",
-            pip=env_dir / "Scripts" / "pip.exe",
-            site_packages=env_dir / "Lib" / "site-packages",
-            bin_dir=env_dir / "Scripts"
-        )
-
-    def check_prerequisites(self) -> Tuple[bool, Optional[str]]:
-        # Check for MSYS2/Cygwin/Git Bash
-        shell_env = self._detect_shell_environment()
-        if shell_env in ('msys2', 'cygwin', 'git-bash'):
-            return (False,
-                    f"Running in {shell_env.upper()} environment.\n"
-                    f"This package requires native Windows Python.\n"
-                    f"Please use PowerShell, Command Prompt, or native Windows terminal.")
-        # Note: VC++ runtime is handled by msvc-runtime package, no system check needed
-        return (True, None)
-
-    def _detect_shell_environment(self) -> str:
-        """Detect if running in MSYS2, Cygwin, Git Bash, or native Windows."""
-        msystem = os.environ.get('MSYSTEM', '')
-        if msystem:
-            if 'MINGW' in msystem:
-                return 'git-bash'
-            return 'msys2'
-
-        term = os.environ.get('TERM', '')
-        if term and 'cygwin' in term:
-            return 'cygwin'
-
-        return 'native-windows'
-
-    def make_executable(self, path: Path) -> None:
-        # No-op on Windows - executables are determined by extension
-        pass
-
-    def rmtree_robust(self, path: Path, max_retries: int = 5, delay: float = 0.5) -> bool:
-        """
-        Windows-specific rmtree with retry logic for file locking issues.
-
-        Handles Windows file locking, read-only files, and antivirus interference.
-        """
-        def handle_remove_readonly(func, fpath, exc):
-            """Error handler for removing read-only files."""
-            if isinstance(exc[1], PermissionError):
-                try:
-                    os.chmod(fpath, stat.S_IWRITE)
-                    func(fpath)
-                except Exception:
-                    raise exc[1]
-            else:
-                raise exc[1]
-
-        for attempt in range(max_retries):
-            try:
-                shutil.rmtree(path, onerror=handle_remove_readonly)
-                return True
-            except PermissionError:
-                if attempt < max_retries - 1:
-                    wait_time = delay * (2 ** attempt)
-                    time.sleep(wait_time)
-                else:
-                    raise
-            except OSError:
-                if attempt < max_retries - 1:
-                    wait_time = delay * (2 ** attempt)
-                    time.sleep(wait_time)
-                else:
-                    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/pixi/resolver.py

@@ -1,198 +0,0 @@
-import platform
-import sys
-from dataclasses import dataclass
-from typing import Dict, Optional, Tuple
-
-from .cuda_detection import detect_cuda_version, detect_gpu_info
-
-
-@dataclass
-class RuntimeEnv:
-    """
-    Detected runtime environment for wheel resolution.
-
-    Contains all variables needed for wheel URL template expansion.
-    """
-    # OS/Platform
-    os_name: str  # linux, windows, darwin
-    platform_tag: str  # linux_x86_64, win_amd64, macosx_...
-
-    # Python
-    python_version: str  # 3.10, 3.11, 3.12
-    python_short: str  # 310, 311, 312
-
-    # CUDA
-    cuda_version: Optional[str]  # 12.8, 12.4, None
-    cuda_short: Optional[str]  # 128, 124, None
-
-    # PyTorch (detected or configured)
-    torch_version: Optional[str]  # 2.8.0, 2.5.1
-    torch_short: Optional[str]  # 280, 251
-    torch_mm: Optional[str]  # 28, 25 (major.minor without dot)
-
-    # GPU info
-    gpu_name: Optional[str] = None
-    gpu_compute: Optional[str] = None  # sm_89, sm_100
-
-    @classmethod
-    def detect(cls, torch_version: Optional[str] = None) -> "RuntimeEnv":
-        """
-        Detect runtime environment from current system.
-
-        Args:
-            torch_version: Optional PyTorch version override. If not provided,
-                          attempts to detect from installed torch.
-
-        Returns:
-            RuntimeEnv with detected values.
-        """
-        # OS detection
-        os_name = sys.platform
-        if os_name.startswith('linux'):
-            os_name = 'linux'
-        elif os_name == 'win32':
-            os_name = 'windows'
-        elif os_name == 'darwin':
-            os_name = 'darwin'
-
-        # Platform tag
-        platform_tag = _get_platform_tag()
-
-        # Python version
-        py_version = f"{sys.version_info.major}.{sys.version_info.minor}"
-        py_short = f"{sys.version_info.major}{sys.version_info.minor}"
-
-        # CUDA version
-        cuda_version = detect_cuda_version()
-        cuda_short = cuda_version.replace(".", "") if cuda_version else None
-
-        # PyTorch version
-        if torch_version is None:
-            torch_version = _detect_torch_version()
-
-        torch_short = None
-        torch_mm = None
-        if torch_version:
-            torch_short = torch_version.replace(".", "")
-            parts = torch_version.split(".")[:2]
-            torch_mm = "".join(parts)
-
-        # GPU info
-        gpu_name = None
-        gpu_compute = None
-        try:
-            gpu_info = detect_gpu_info()
-            if gpu_info:
-                gpu_name = gpu_info[0].get("name") if isinstance(gpu_info, list) else gpu_info.get("name")
-                gpu_compute = gpu_info[0].get("compute_capability") if isinstance(gpu_info, list) else gpu_info.get("compute_capability")
-        except Exception:
-            pass
-
-        return cls(
-            os_name=os_name,
-            platform_tag=platform_tag,
-            python_version=py_version,
-            python_short=py_short,
-            cuda_version=cuda_version,
-            cuda_short=cuda_short,
-            torch_version=torch_version,
-            torch_short=torch_short,
-            torch_mm=torch_mm,
-            gpu_name=gpu_name,
-            gpu_compute=gpu_compute,
-        )
-
-    def as_dict(self) -> Dict[str, str]:
-        """Convert to dict for template substitution."""
-        py_minor = self.python_version.split(".")[-1] if self.python_version else ""
-
-        result = {
-            "os": self.os_name,
-            "platform": self.platform_tag,
-            "python_version": self.python_version,
-            "py_version": self.python_version,
-            "py_short": self.python_short,
-            "py_minor": py_minor,
-            "py_tag": f"cp{self.python_short}",
-        }
-
-        if self.cuda_version:
-            result["cuda_version"] = self.cuda_version
-            result["cuda_short"] = self.cuda_short
-            result["cuda_major"] = self.cuda_version.split(".")[0]
-
-        if self.torch_version:
-            result["torch_version"] = self.torch_version
-            result["torch_short"] = self.torch_short
-            result["torch_mm"] = self.torch_mm
-            parts = self.torch_version.split(".")[:2]
-            result["torch_dotted_mm"] = ".".join(parts)
-
-        return result
-
-    def __str__(self) -> str:
-        parts = [
-            f"Python {self.python_version}",
-            f"CUDA {self.cuda_version}" if self.cuda_version else "CPU",
-        ]
-        if self.torch_version:
-            parts.append(f"PyTorch {self.torch_version}")
-        if self.gpu_name:
-            parts.append(f"GPU: {self.gpu_name}")
-        return ", ".join(parts)
-
-
-def _get_platform_tag() -> str:
-    """Get wheel platform tag for current system."""
-    machine = platform.machine().lower()
-
-    if sys.platform.startswith('linux'):
-        if machine in ('x86_64', 'amd64'):
-            return 'linux_x86_64'
-        elif machine == 'aarch64':
-            return 'linux_aarch64'
-        return f'linux_{machine}'
-
-    elif sys.platform == 'win32':
-        if machine in ('amd64', 'x86_64'):
-            return 'win_amd64'
-        return 'win32'
-
-    elif sys.platform == 'darwin':
-        if machine == 'arm64':
-            return 'macosx_11_0_arm64'
-        return 'macosx_10_9_x86_64'
-
-    return f'{sys.platform}_{machine}'
-
-
-def _detect_torch_version() -> Optional[str]:
-    """Detect installed PyTorch version."""
-    try:
-        import torch
-        version = torch.__version__
-        if '+' in version:
-            version = version.split('+')[0]
-        return version
-    except ImportError:
-        return None
-
-
-def parse_wheel_requirement(req: str) -> Tuple[str, Optional[str]]:
-    """
-    Parse a wheel requirement string.
-
-    Examples:
-        "nvdiffrast==0.4.0" -> ("nvdiffrast", "0.4.0")
-        "pytorch3d>=0.7.8" -> ("pytorch3d", "0.7.8")
-        "torch-cluster" -> ("torch-cluster", None)
-
-    Returns:
-        Tuple of (package_name, version_or_None).
-    """
-    for op in ['==', '>=', '<=', '~=', '!=', '>', '<']:
-        if op in req:
-            parts = req.split(op, 1)
-            return (parts[0].strip(), parts[1].strip())
-
-    return (req.strip(), None)

comfy_env/prestartup.py

@@ -1,192 +0,0 @@
-"""
-Prestartup helpers for ComfyUI custom nodes.
-
-Call setup_env() in your prestartup_script.py before any native imports.
-"""
-
-import glob
-import os
-import sys
-from pathlib import Path
-from typing import Optional, Dict
-
-
-def get_env_name(dir_name: str) -> str:
-    """Convert directory name to env name: ComfyUI-UniRig -> _env_unirig"""
-    name = dir_name.lower().replace("-", "_").lstrip("comfyui_")
-    return f"_env_{name}"
-
-
-def _load_env_vars(config_path: str) -> Dict[str, str]:
-    """
-    Load [env_vars] section from comfy-env.toml.
-
-    Uses tomllib (Python 3.11+) or tomli fallback.
-    Returns empty dict if file not found or parsing fails.
-    """
-    if not os.path.exists(config_path):
-        return {}
-
-    try:
-        if sys.version_info >= (3, 11):
-            import tomllib
-        else:
-            try:
-                import tomli as tomllib
-            except ImportError:
-                return {}
-
-        with open(config_path, "rb") as f:
-            data = tomllib.load(f)
-
-        env_vars_data = data.get("env_vars", {})
-        return {str(k): str(v) for k, v in env_vars_data.items()}
-    except Exception:
-        return {}
-
-
-def _dedupe_libomp_macos():
-    """
-    macOS: Dedupe libomp.dylib to prevent OpenMP runtime conflicts.
-
-    Torch and other packages (PyMeshLab, etc.) bundle their own libomp.
-    Two OpenMP runtimes in same process = crash.
-    Fix: symlink all libomp copies to torch's (canonical source).
-    """
-    if sys.platform != "darwin":
-        return
-
-    # Find torch's libomp (canonical source) via introspection
-    try:
-        import torch
-        torch_libomp = os.path.join(os.path.dirname(torch.__file__), 'lib', 'libomp.dylib')
-        if not os.path.exists(torch_libomp):
-            return
-    except ImportError:
-        return  # No torch, skip
-
-    # Find site-packages for scanning
-    site_packages = os.path.dirname(os.path.dirname(torch.__file__))
-
-    # Find other libomp files and symlink to torch's
-    patterns = [
-        os.path.join(site_packages, '*', 'Frameworks', 'libomp.dylib'),
-        os.path.join(site_packages, '*', '.dylibs', 'libomp.dylib'),
-        os.path.join(site_packages, '*', 'lib', 'libomp.dylib'),
-    ]
-
-    for pattern in patterns:
-        for libomp in glob.glob(pattern):
-            # Skip torch's own copy
-            if 'torch' in libomp:
-                continue
-            # Skip if already a symlink pointing to torch
-            if os.path.islink(libomp):
-                if os.path.realpath(libomp) == os.path.realpath(torch_libomp):
-                    continue
-            # Replace with symlink to torch's
-            try:
-                if os.path.islink(libomp):
-                    os.unlink(libomp)
-                else:
-                    os.rename(libomp, libomp + '.bak')
-                os.symlink(torch_libomp, libomp)
-            except OSError:
-                pass  # Permission denied, etc.
-
-
-def setup_env(node_dir: Optional[str] = None) -> None:
-    """
-    Set up environment for pixi conda libraries.
-
-    Call this in prestartup_script.py before any native library imports.
-    - Applies [env_vars] from comfy-env.toml first (for OpenMP settings, etc.)
-    - Sets LD_LIBRARY_PATH (Linux/Mac) or PATH (Windows) for conda libs
-    - Adds pixi site-packages to sys.path
-
-    Args:
-        node_dir: Path to the custom node directory. Auto-detected if not provided.
-
-    Example:
-        # In prestartup_script.py:
-        from comfy_env import setup_env
-        setup_env()
-    """
-    # macOS: Dedupe libomp to prevent OpenMP conflicts (torch vs pymeshlab, etc.)
-    _dedupe_libomp_macos()
-
-    # Auto-detect node_dir from caller
-    if node_dir is None:
-        import inspect
-        frame = inspect.stack()[1]
-        node_dir = str(Path(frame.filename).parent)
-
-    # Apply [env_vars] from comfy-env.toml FIRST (before any library loading)
-    config_path = os.path.join(node_dir, "comfy-env.toml")
-    env_vars = _load_env_vars(config_path)
-    for key, value in env_vars.items():
-        os.environ[key] = value
-
-    # Resolve environment path with fallback chain:
-    # 1. Marker file -> central cache
-    # 2. _env_<name> (current local)
-    # 3. .pixi/envs/default (old pixi)
-    pixi_env = None
-
-    # 1. Check marker file -> central cache
-    marker_path = os.path.join(node_dir, ".comfy-env-marker.toml")
-    if os.path.exists(marker_path):
-        try:
-            if sys.version_info >= (3, 11):
-                import tomllib
-            else:
-                import tomli as tomllib
-            with open(marker_path, "rb") as f:
-                marker = tomllib.load(f)
-            env_path = marker.get("env", {}).get("path")
-            if env_path and os.path.exists(env_path):
-                pixi_env = env_path
-        except Exception:
-            pass  # Fall through to other options
-
-    # 2. Check _env_<name> (local)
-    if not pixi_env:
-        env_name = get_env_name(os.path.basename(node_dir))
-        local_env = os.path.join(node_dir, env_name)
-        if os.path.exists(local_env):
-            pixi_env = local_env
-
-    # 3. Fallback to old .pixi path
-    if not pixi_env:
-        old_pixi = os.path.join(node_dir, ".pixi", "envs", "default")
-        if os.path.exists(old_pixi):
-            pixi_env = old_pixi
-
-    if not pixi_env:
-        return  # No environment found
-
-    if sys.platform == "win32":
-        # Windows: add to PATH for DLL loading
-        lib_dir = os.path.join(pixi_env, "Library", "bin")
-        if os.path.exists(lib_dir):
-            os.environ["PATH"] = lib_dir + ";" + os.environ.get("PATH", "")
-    elif sys.platform == "darwin":
-        # macOS: DYLD_LIBRARY_PATH
-        lib_dir = os.path.join(pixi_env, "lib")
-        if os.path.exists(lib_dir):
-            os.environ["DYLD_LIBRARY_PATH"] = lib_dir + ":" + os.environ.get("DYLD_LIBRARY_PATH", "")
-    else:
-        # Linux: LD_LIBRARY_PATH
-        lib_dir = os.path.join(pixi_env, "lib")
-        if os.path.exists(lib_dir):
-            os.environ["LD_LIBRARY_PATH"] = lib_dir + ":" + os.environ.get("LD_LIBRARY_PATH", "")
-
-    # Add site-packages to sys.path for pixi-installed Python packages
-    if sys.platform == "win32":
-        site_packages = os.path.join(pixi_env, "Lib", "site-packages")
-    else:
-        matches = glob.glob(os.path.join(pixi_env, "lib", "python*", "site-packages"))
-        site_packages = matches[0] if matches else None
-
-    if site_packages and os.path.exists(site_packages) and site_packages not in sys.path:
-        sys.path.insert(0, site_packages)