comfy-env 0.0.12__tar.gz → 0.0.14__tar.gz

{comfy_env-0.0.12 → comfy_env-0.0.14}/.gitignore

@@ -19,6 +19,9 @@ ENV/
 *.swp
 *.swo
 
+# Jupyter
+.ipynb_checkpoints/
+
 # Testing
 .pytest_cache/
 .coverage

{comfy_env-0.0.12 → comfy_env-0.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.12
+Version: 0.0.14
 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
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
+Requires-Dist: pyyaml>=6.0
 Requires-Dist: tomli>=2.0.0; python_version < '3.11'
 Requires-Dist: uv>=0.4.0
 Provides-Extra: dev

{comfy_env-0.0.12 → comfy_env-0.0.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfy-env"
-version = "0.0.12"
+version = "0.0.14"
 description = "Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation"
 readme = "README.md"
 license = {text = "MIT"}
@@ -21,6 +21,7 @@ classifiers = [
 dependencies = [
     "tomli>=2.0.0; python_version < '3.11'",  # TOML parsing (built-in tomllib for 3.11+)
     "uv>=0.4.0",  # Fast Python package installer and venv creator
+    "pyyaml>=6.0",  # YAML parsing for wheel_sources.yml
 ]
 
 [project.optional-dependencies]
@@ -41,6 +42,9 @@ build-backend = "hatchling.build"
 [tool.hatch.build.targets.wheel]
 packages = ["src/comfy_env"]
 
+[tool.hatch.build.targets.wheel.force-include]
+"src/comfy_env/wheel_sources.yml" = "comfy_env/wheel_sources.yml"
+
 [tool.ruff]
 line-length = 100
 target-version = "py310"

{comfy_env-0.0.12 → comfy_env-0.0.14}/src/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-0.0.12 → comfy_env-0.0.14}/src/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", {}))
@@ -582,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
@@ -612,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-0.0.12 → comfy_env-0.0.14}/src/comfy_env/env/detection.py

@@ -92,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).

{comfy_env-0.0.12 → comfy_env-0.0.14}/src/comfy_env/env/manager.py

@@ -475,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,
@@ -484,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-0.0.12 → comfy_env-0.0.14}/src/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-0.0.12 → comfy_env-0.0.14}/src/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-0.0.12 → comfy_env-0.0.14}/src/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,

comfy_env-0.0.14/src/comfy_env/registry.py

@@ -0,0 +1,91 @@
+"""Built-in registry of CUDA packages and their wheel sources.
+
+This module loads package configurations from wheel_sources.yml and provides
+lookup functions for the install module.
+
+Install method types:
+- "index": Use pip --extra-index-url (PEP 503 simple repository)
+- "github_index": GitHub Pages index (--find-links)
+- "find_links": Use pip --find-links (for PyG, etc.)
+- "pypi_variant": Package name varies by CUDA version (e.g., spconv-cu124)
+- "github_release": Direct wheel URL from GitHub releases with fallback sources
+- "pypi": Standard PyPI install
+"""
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+
+
+def get_cuda_short2(cuda_version: str) -> str:
+    """Convert CUDA version to 2-3 digit format for spconv.
+
+    spconv uses "cu124" not "cu1240" for CUDA 12.4.
+
+    Args:
+        cuda_version: CUDA version string (e.g., "12.4", "12.8")
+
+    Returns:
+        Short format string (e.g., "124", "128")
+
+    Examples:
+        >>> get_cuda_short2("12.4")
+        '124'
+        >>> get_cuda_short2("12.8")
+        '128'
+        >>> get_cuda_short2("11.8")
+        '118'
+    """
+    parts = cuda_version.split(".")
+    major = parts[0]
+    minor = parts[1] if len(parts) > 1 else "0"
+    return f"{major}{minor}"
+
+
+def _load_wheel_sources() -> Dict[str, Dict[str, Any]]:
+    """Load package registry from wheel_sources.yml."""
+    yml_path = Path(__file__).parent / "wheel_sources.yml"
+    with open(yml_path, "r") as f:
+        data = yaml.safe_load(f)
+    return data.get("packages", {})
+
+
+# Load registry at module import time
+PACKAGE_REGISTRY: Dict[str, Dict[str, Any]] = _load_wheel_sources()
+
+
+def get_package_info(package: str) -> Optional[Dict[str, Any]]:
+    """Get registry info for a package.
+
+    Args:
+        package: Package name (case-insensitive)
+
+    Returns:
+        Registry entry dict or None if not found
+    """
+    return PACKAGE_REGISTRY.get(package.lower())
+
+
+def list_packages() -> Dict[str, str]:
+    """List all registered packages with their descriptions.
+
+    Returns:
+        Dict mapping package name to description
+    """
+    return {
+        name: info.get("description", "No description")
+        for name, info in PACKAGE_REGISTRY.items()
+    }
+
+
+def is_registered(package: str) -> bool:
+    """Check if a package is in the registry.
+
+    Args:
+        package: Package name (case-insensitive)
+
+    Returns:
+        True if package is registered
+    """
+    return package.lower() in PACKAGE_REGISTRY

{comfy_env-0.0.12 → comfy_env-0.0.14}/src/comfy_env/resolver.py

@@ -137,11 +137,14 @@ class RuntimeEnv:
             "py_version": self.python_version,
             "py_short": self.python_short,
             "py_minor": py_minor,
+            "py_tag": f"cp{self.python_short}",  # e.g., cp310, cp311
         }
 
         if self.cuda_version:
             result["cuda_version"] = self.cuda_version
             result["cuda_short"] = self.cuda_short
+            # cuda_major: just the major version (e.g., "12" from "12.8")
+            result["cuda_major"] = self.cuda_version.split(".")[0]
 
         if self.torch_version:
             result["torch_version"] = self.torch_version
@@ -218,21 +221,6 @@ class WheelSource:
         return package.lower() in [p.lower() for p in self.packages]
 
 
-# Default wheel sources for common CUDA packages
-DEFAULT_WHEEL_SOURCES = [
-    WheelSource(
-        name="nvdiffrast-wheels",
-        url_template="https://github.com/PozzettiAndrea/nvdiffrast-full-wheels/releases/download/v{version}/nvdiffrast-{version}%2Bcu{cuda_short}torch{torch_mm}-cp{py_short}-cp{py_short}-{platform}.whl",
-        packages=["nvdiffrast"],
-    ),
-    WheelSource(
-        name="cumesh-wheels",
-        url_template="https://github.com/PozzettiAndrea/cumesh-wheels/releases/download/v{version}/{package}-{version}%2Bcu{cuda_short}torch{torch_mm}-cp{py_short}-cp{py_short}-{platform}.whl",
-        packages=["pytorch3d", "torch-cluster", "torch-scatter", "torch-sparse"],
-    ),
-]
-
-
 class WheelResolver:
     """
     Resolves CUDA wheel URLs from package name and runtime environment.
@@ -255,10 +243,11 @@ class WheelResolver:
         Initialize resolver.
 
         Args:
-            sources: List of WheelSource configurations.
+            sources: List of WheelSource configurations. Defaults to empty
+                    (use PACKAGE_REGISTRY in install.py for actual sources).
             overrides: Package-specific URL overrides (package -> template).
         """
-        self.sources = sources or DEFAULT_WHEEL_SOURCES
+        self.sources = sources or []
         self.overrides = overrides or {}
 
     def resolve(