comfy-env 0.0.8__py3-none-any.whl → 0.0.14__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.8"
+__version__ = "0.0.11"
 
 from .env.config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq
 from .env.config_file import (

comfy_env/cli.py

@@ -234,6 +234,7 @@ def cmd_info(args) -> int:
 def cmd_resolve(args) -> int:
     """Handle resolve command."""
     from .resolver import RuntimeEnv, WheelResolver, parse_wheel_requirement
+    from .registry import PACKAGE_REGISTRY
     from .env.config_file import discover_env_config, load_env_from_file
 
     env = RuntimeEnv.detect()
@@ -270,19 +271,116 @@ def cmd_resolve(args) -> int:
             print(f"  {package}: No version specified, skipping")
             continue
 
+        pkg_lower = package.lower()
         try:
-            url = resolver.resolve(package, version, env, verify=args.verify)
-            status = "OK" if args.verify else "resolved"
-            print(f"  {package}=={version}: {status}")
-            print(f"    {url}")
+            # Check if package is in registry with github_release method
+            if pkg_lower in PACKAGE_REGISTRY:
+                registry_config = PACKAGE_REGISTRY[pkg_lower]
+                method = registry_config.get("method")
+
+                if method == "github_release":
+                    # Resolve URL from registry sources
+                    url = _resolve_github_release_url(package, version, env, registry_config)
+                    status = "OK" if args.verify else "resolved"
+                    print(f"  {package}=={version}: {status}")
+                    print(f"    {url}")
+                else:
+                    # For other methods, just show what method will be used
+                    print(f"  {package}=={version}: uses {method} method")
+                    if "index_url" in registry_config:
+                        index_url = _substitute_template(registry_config["index_url"], env)
+                        print(f"    index: {index_url}")
+                    elif "package_template" in registry_config:
+                        pkg_name = _substitute_template(registry_config["package_template"], env)
+                        print(f"    installs as: {pkg_name}")
+            else:
+                # Fall back to WheelResolver
+                url = resolver.resolve(package, version, env, verify=args.verify)
+                status = "OK" if args.verify else "resolved"
+                print(f"  {package}=={version}: {status}")
+                print(f"    {url}")
         except Exception as e:
             print(f"  {package}=={version}: FAILED")
-            print(f"    {e}")
+            _print_wheel_not_found_error(package, version, env, e)
             all_ok = False
 
     return 0 if all_ok else 1
 
 
+def _substitute_template(template: str, env) -> str:
+    """Substitute environment variables into a URL template."""
+    vars_dict = env.as_dict()
+    result = template
+    for key, value in vars_dict.items():
+        if value is not None:
+            result = result.replace(f"{{{key}}}", str(value))
+    return result
+
+
+def _resolve_github_release_url(package: str, version: str, env, config: dict) -> str:
+    """Resolve URL for github_release method packages."""
+    sources = config.get("sources", [])
+    if not sources:
+        raise ValueError(f"No sources configured for {package}")
+
+    # Build template variables
+    vars_dict = env.as_dict()
+    vars_dict["version"] = version
+    vars_dict["py_tag"] = f"cp{env.python_short}"
+    if env.cuda_version:
+        vars_dict["cuda_major"] = env.cuda_version.split(".")[0]
+
+    # Filter sources by platform
+    current_platform = env.platform_tag
+    compatible_sources = [
+        s for s in sources
+        if current_platform in s.get("platforms", [])
+    ]
+
+    if not compatible_sources:
+        available = set()
+        for s in sources:
+            available.update(s.get("platforms", []))
+        raise ValueError(
+            f"No {package} wheels for platform {current_platform}. "
+            f"Available: {', '.join(sorted(available))}"
+        )
+
+    # Return URL from first compatible source
+    source = compatible_sources[0]
+    url_template = source.get("url_template", "")
+    url = url_template
+    for key, value in vars_dict.items():
+        if value is not None:
+            url = url.replace(f"{{{key}}}", str(value))
+
+    return url
+
+
+def _print_wheel_not_found_error(package: str, version: str, env, error: Exception) -> None:
+    """Print a formatted error message for wheel not found."""
+    from .errors import WheelNotFoundError
+
+    if isinstance(error, WheelNotFoundError):
+        print(f"    CUDA wheel not found: {package}=={version}")
+        print()
+        print("+------------------------------------------------------------------+")
+        print("|  CUDA Wheel Not Found                                            |")
+        print("+------------------------------------------------------------------+")
+        print(f"|  Package:   {package}=={version:<46} |")
+        print(f"|  Requested: cu{env.cuda_short}-torch{env.torch_mm}-{env.python_short}-{env.platform_tag:<17} |")
+        print("|                                                                  |")
+        print(f"|  Reason: {error.reason:<54} |")
+        print("|                                                                  |")
+        print("|  Suggestions:                                                    |")
+        print(f"|    1. Check if wheel exists: comfy-env resolve {package:<15} |")
+        print(f"|    2. Build wheel locally: comfy-env build {package:<18} |")
+        print("|                                                                  |")
+        print("+------------------------------------------------------------------+")
+    else:
+        print(f"    {error}")
+
+
 def cmd_doctor(args) -> int:
     """Handle doctor command."""
     from .install import verify_installation

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

@@ -168,7 +168,7 @@ def _get_default_pytorch_version(cuda_version: Optional[str]) -> str:
         - CUDA 12.8 (Turing+): PyTorch 2.8.0
     """
     if cuda_version == "12.4":
-        return "2.5.1"  # Legacy: Pascal GPUs
+        return "2.5.1"  # Full: Pascal GPUs
     return "2.8.0"  # Modern: Turing through Blackwell
 
 
@@ -176,7 +176,7 @@ def _parse_config(data: Dict[str, Any], base_dir: Path) -> IsolatedEnv:
     """
     Parse TOML data into IsolatedEnv.
 
-    Supports both simplified and legacy config formats:
+    Supports both simplified and full config formats:
 
     Simplified (CUDA packages only):
         [packages]
@@ -186,7 +186,7 @@ def _parse_config(data: Dict[str, Any], base_dir: Path) -> IsolatedEnv:
     Or as list:
         packages = ["torch-scatter==2.1.2", "torch-cluster==1.6.3"]
 
-    Legacy:
+    Full:
         [env]
         name = "my-node"
         [packages]
@@ -233,7 +233,7 @@ def _parse_config(data: Dict[str, Any], base_dir: Path) -> IsolatedEnv:
         variables.setdefault("pytorch_mm", pytorch_mm)
 
     # Parse CUDA packages - support multiple formats
-    # Priority: [cuda] section > cuda = [...] > legacy [packages] section
+    # Priority: [cuda] section > cuda = [...] > [packages] section
     no_deps_requirements = []
     requirements = []
 
@@ -258,12 +258,12 @@ def _parse_config(data: Dict[str, Any], base_dir: Path) -> IsolatedEnv:
 
     elif isinstance(packages_section, dict):
         # Check for simplified format: [packages] with key=value pairs
-        # vs legacy format: [packages] with requirements/no_deps lists
+        # vs old format: [packages] with requirements/no_deps lists
 
-        has_legacy_keys = any(k in packages_section for k in ["requirements", "no_deps", "requirements_file"])
+        has_old_keys = any(k in packages_section for k in ["requirements", "no_deps", "requirements_file"])
 
-        if has_legacy_keys:
-            # Legacy format
+        if has_old_keys:
+            # Old format
             raw_requirements = packages_section.get("requirements", [])
             requirements = [_substitute_vars(req, variables) for req in raw_requirements]
 
@@ -340,9 +340,9 @@ def load_config(
     base_dir: Optional[Path] = None,
 ) -> EnvManagerConfig:
     """
-    Load full EnvManagerConfig from a TOML file (v2 schema).
+    Load full EnvManagerConfig from a TOML file.
 
-    Supports both v2 schema and legacy format (auto-detected).
+    Supports both full schema (named envs) and simple format (auto-detected).
 
     Args:
         path: Path to the TOML config file
@@ -373,7 +373,7 @@ def load_config(
     with open(path, "rb") as f:
         data = tomllib.load(f)
 
-    return _parse_config_v2(data, base_dir)
+    return _parse_full_config(data, base_dir)
 
 
 def discover_config(
@@ -404,9 +404,9 @@ def discover_config(
     return None
 
 
-def _parse_config_v2(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
+def _parse_full_config(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
     """
-    Parse TOML data into EnvManagerConfig (v2 schema).
+    Parse TOML data into EnvManagerConfig.
 
     Schema:
         [local.cuda]        - CUDA packages for host
@@ -416,16 +416,16 @@ def _parse_config_v2(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
         [envname.packages]  - Packages for env
         [node_reqs]         - Node dependencies
 
-    Also supports legacy format for backward compatibility.
+    Also supports simple format ([env] + [packages]) for backward compatibility.
     """
-    # Detect if this is v2 schema or legacy
-    is_v2 = "local" in data or _has_named_env(data)
+    # Detect if this is full schema or simple format
+    is_full = "local" in data or _has_named_env(data)
 
-    if not is_v2:
-        # Legacy format - convert to v2 structure
-        return _convert_legacy_to_v2(data, base_dir)
+    if not is_full:
+        # Simple format - convert to full structure
+        return _convert_simple_to_full(data, base_dir)
 
-    # Parse v2 schema
+    # Parse full schema
     local = _parse_local_section(data.get("local", {}))
     envs = _parse_env_sections(data, base_dir)
     node_reqs = _parse_node_reqs(data.get("node_reqs", {}))
@@ -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,
     )
 
 
@@ -555,27 +582,30 @@ def _parse_node_reqs(node_reqs_data: Dict[str, Any]) -> List[NodeReq]:
     return reqs
 
 
-def _convert_legacy_to_v2(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
-    """Convert legacy config format to v2 EnvManagerConfig."""
-    # Parse using legacy parser to get IsolatedEnv
-    legacy_env = _parse_config(data, base_dir)
+def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
+    """Convert simple config format to full EnvManagerConfig.
 
-    # Check if this is really just a Type 2 config (local CUDA only, no venv)
-    # Type 2 indicators: no [env] section with name, or name matches directory
+    Simple configs have [env] and [packages] sections but no named environments.
+    This converts them to the full format with a single named environment.
+    """
+    # Parse using simple parser to get IsolatedEnv
+    simple_env = _parse_config(data, base_dir)
+
+    # Check if this has explicit env settings (isolated venv) vs just CUDA packages (local install)
     env_section = data.get("env", {})
     has_explicit_env = bool(env_section.get("name") or env_section.get("python"))
 
     if has_explicit_env:
-        # This is a Type 1 config (isolated venv)
+        # Isolated venv config
         return EnvManagerConfig(
             local=LocalConfig(),
-            envs={legacy_env.name: legacy_env},
+            envs={simple_env.name: simple_env},
             node_reqs=[],
         )
     else:
-        # This is a Type 2 config (local CUDA only)
+        # Local CUDA packages only (no isolated venv)
         cuda_packages = {}
-        for req in legacy_env.no_deps_requirements:
+        for req in simple_env.no_deps_requirements:
             if "==" in req:
                 pkg, ver = req.split("==", 1)
                 cuda_packages[pkg] = ver
@@ -585,8 +615,8 @@ def _convert_legacy_to_v2(data: Dict[str, Any], base_dir: Path) -> EnvManagerCon
         return EnvManagerConfig(
             local=LocalConfig(
                 cuda_packages=cuda_packages,
-                requirements=legacy_env.requirements,
+                requirements=simple_env.requirements,
             ),
             envs={},
             node_reqs=[],
-        )
+        )

comfy_env/env/detection.py

@@ -7,10 +7,16 @@ vs older GPUs which use CUDA 12.4.
 This runs BEFORE PyTorch is installed, so we use nvidia-smi directly.
 """
 
+import os
 import subprocess
 from typing import List, Dict, Optional
 
 
+# Environment variable to override CUDA version detection
+# Useful for CI environments without GPU
+CUDA_VERSION_ENV_VAR = "COMFY_ENV_CUDA_VERSION"
+
+
 def detect_gpu_info() -> List[Dict[str, str]]:
     """
     Detect GPU name and compute capability using nvidia-smi.
@@ -86,22 +92,6 @@ def is_blackwell_gpu(name: str, compute_cap: str) -> bool:
     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).
@@ -126,7 +116,12 @@ def detect_cuda_version() -> Optional[str]:
     Returns:
         "12.4" for Pascal or older (compute < 7.5),
         "12.8" for Turing or newer (compute >= 7.5),
-        None if no GPU detected.
+        None if no GPU detected and no env var override.
+
+    Environment Variable Override:
+        Set COMFY_ENV_CUDA_VERSION to override auto-detection.
+        Useful for CI environments without GPU.
+        Example: COMFY_ENV_CUDA_VERSION=12.8
 
     GPU Architecture Reference:
         - Pascal (GTX 10xx, P100): compute 6.0-6.1 → CUDA 12.4
@@ -138,6 +133,15 @@ def detect_cuda_version() -> Optional[str]:
     """
     gpus = detect_gpu_info()
     if not gpus:
+        # No GPU detected - check for env var override
+        override = os.environ.get(CUDA_VERSION_ENV_VAR)
+        if override:
+            # Normalize format (e.g., "12.8" or "128" -> "12.8")
+            override = override.strip()
+            if override and '.' not in override and len(override) >= 2:
+                # Convert "128" -> "12.8"
+                override = f"{override[:-1]}.{override[-1]}"
+            return override
         return None
 
     # Check if any GPU is legacy (Pascal or older)
@@ -159,7 +163,10 @@ def get_gpu_summary() -> str:
     gpus = detect_gpu_info()
 
     if not gpus:
-        return "No NVIDIA GPU detected"
+        override = os.environ.get(CUDA_VERSION_ENV_VAR)
+        if override:
+            return f"No NVIDIA GPU detected (using {CUDA_VERSION_ENV_VAR}={override})"
+        return f"No NVIDIA GPU detected (set {CUDA_VERSION_ENV_VAR} to override)"
 
     lines = []
     for i, gpu in enumerate(gpus):

comfy_env/env/manager.py

@@ -6,6 +6,7 @@ Uses uv for fast environment creation and package installation.
 
 import subprocess
 import shutil
+import sys
 from pathlib import Path
 from typing import Optional, Callable
 
@@ -263,13 +264,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 +328,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,
             )
@@ -458,7 +475,7 @@ class IsolatedEnvManager:
             url_template = source["url_template"]
             url = self._substitute_template(url_template, vars_dict)
 
-            self.log(f"    Trying {source.get('name', 'unknown')}: {url[:80]}...")
+            self.log(f"    Trying {source.get('name', 'unknown')}: {url}")
             result = subprocess.run(
                 pip_args + ["--no-deps", url],
                 capture_output=True, text=True,
@@ -467,7 +484,7 @@ class IsolatedEnvManager:
             if result.returncode == 0:
                 return  # Success!
 
-            errors.append(f"{source.get('name', 'unknown')}: {result.stderr[:100]}")
+            errors.append(f"{source.get('name', 'unknown')}: {result.stderr.strip()}")
 
         # All sources failed
         raise RuntimeError(

comfy_env/errors.py

@@ -291,35 +291,3 @@ class InstallError(EnvManagerError):
 
         details = "\n".join(details_parts) if details_parts else None
         super().__init__(message, details)
-
-
-def format_environment_mismatch(
-    expected: "RuntimeEnv",
-    actual: "RuntimeEnv",
-) -> str:
-    """
-    Format a message explaining environment mismatch.
-
-    Used when the current environment doesn't match what's needed.
-    """
-    mismatches = []
-
-    if expected.cuda_version != actual.cuda_version:
-        mismatches.append(
-            f"  CUDA: expected {expected.cuda_version}, got {actual.cuda_version}"
-        )
-
-    if expected.torch_version != actual.torch_version:
-        mismatches.append(
-            f"  PyTorch: expected {expected.torch_version}, got {actual.torch_version}"
-        )
-
-    if expected.python_version != actual.python_version:
-        mismatches.append(
-            f"  Python: expected {expected.python_version}, got {actual.python_version}"
-        )
-
-    if not mismatches:
-        return "Environment matches expected configuration"
-
-    return "Environment mismatch:\n" + "\n".join(mismatches)

comfy_env/install.py

@@ -421,6 +421,7 @@ def _install_from_github_release(
                 url = url.replace(f"{{{key}}}", str(value))
 
         log(f"  Trying {source_name}: {package}=={version}...")
+        log(f"    Resolved wheel to: {url}")
 
         try:
             pip_cmd = _get_pip_command()

comfy_env/ipc/bridge.py

@@ -48,10 +48,6 @@ class WorkerBridge:
         result = bridge.call("process", image=my_image)
     """
 
-    # Singleton instances by environment hash
-    _instances: Dict[str, "WorkerBridge"] = {}
-    _instances_lock = threading.Lock()
-
     def __init__(
         self,
         env: IsolatedEnv,
@@ -81,38 +77,6 @@ class WorkerBridge:
         self._process_lock = threading.Lock()
         self._stderr_thread: Optional[threading.Thread] = None
 
-    @classmethod
-    def get_instance(
-        cls,
-        env: IsolatedEnv,
-        worker_script: Path,
-        base_dir: Optional[Path] = None,
-        log_callback: Optional[Callable[[str], None]] = None,
-    ) -> "WorkerBridge":
-        """
-        Get or create a singleton bridge instance for an environment.
-
-        Args:
-            env: Isolated environment configuration
-            worker_script: Path to the worker Python script
-            base_dir: Base directory for environments
-            log_callback: Optional callback for logging
-
-        Returns:
-            WorkerBridge instance (reused if same env hash)
-        """
-        env_hash = env.get_env_hash()
-
-        with cls._instances_lock:
-            if env_hash not in cls._instances:
-                cls._instances[env_hash] = cls(
-                    env=env,
-                    worker_script=worker_script,
-                    base_dir=base_dir,
-                    log_callback=log_callback,
-                )
-            return cls._instances[env_hash]
-
     @classmethod
     def from_config_file(
         cls,