comfy-env 0.0.31__tar.gz → 0.0.33__tar.gz

{comfy_env-0.0.31 → comfy_env-0.0.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.31
+Version: 0.0.33
 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.31 → comfy_env-0.0.33}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfy-env"
-version = "0.0.31"
+version = "0.0.33"
 description = "Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation"
 readme = "README.md"
 license = {text = "MIT"}

{comfy_env-0.0.31 → comfy_env-0.0.33}/src/comfy_env/env/manager.py

@@ -22,6 +22,7 @@ from .security import (
 )
 from ..registry import PACKAGE_REGISTRY, is_registered, get_cuda_short2
 from ..resolver import RuntimeEnv, parse_wheel_requirement
+from ..index_resolver import resolve_wheel_from_index
 
 
 class IsolatedEnvManager:
@@ -385,26 +386,48 @@ class IsolatedEnvManager:
                 self.log(f"  Installing {package} ({method})...")
 
                 if method == "index":
-                    # PEP 503 index - use --extra-index-url
+                    # PEP 503 index - try to resolve exact wheel URL first
                     index_url = self._substitute_template(config["index_url"], vars_dict)
                     pkg_spec = f"{package}=={version}" if version else package
-                    self.log(f"    Index: {index_url}")
-                    self.log(f"    Package: {pkg_spec}")
-                    result = subprocess.run(
-                        pip_args + ["--extra-index-url", index_url, "--no-deps", pkg_spec],
-                        capture_output=True, text=True,
-                    )
+                    # Try to resolve exact wheel URL from index
+                    wheel_url = resolve_wheel_from_index(index_url, package, vars_dict, version)
+                    if wheel_url:
+                        # Install from resolved URL directly (guarantees we get what we resolved)
+                        self.log(f"    Wheel: {wheel_url}")
+                        result = subprocess.run(
+                            pip_args + ["--no-deps", wheel_url],
+                            capture_output=True, text=True,
+                        )
+                    else:
+                        # Fallback to index-based resolution
+                        self.log(f"    Index: {index_url}")
+                        self.log(f"    Package: {pkg_spec}")
+                        result = subprocess.run(
+                            pip_args + ["--extra-index-url", index_url, "--no-deps", pkg_spec],
+                            capture_output=True, text=True,
+                        )
 
                 elif method in ("github_index", "find_links"):
                     # GitHub Pages or generic find-links
                     index_url = self._substitute_template(config["index_url"], vars_dict)
                     pkg_spec = f"{package}=={version}" if version else package
-                    self.log(f"    Find-links: {index_url}")
-                    self.log(f"    Package: {pkg_spec}")
-                    result = subprocess.run(
-                        pip_args + ["--find-links", index_url, "--no-deps", pkg_spec],
-                        capture_output=True, text=True,
-                    )
+                    # Try to resolve exact wheel URL from find-links page
+                    wheel_url = resolve_wheel_from_index(index_url, package, vars_dict, version)
+                    if wheel_url:
+                        # Install from resolved URL directly (guarantees we get what we resolved)
+                        self.log(f"    Wheel: {wheel_url}")
+                        result = subprocess.run(
+                            pip_args + ["--no-deps", wheel_url],
+                            capture_output=True, text=True,
+                        )
+                    else:
+                        # Fallback to find-links based resolution
+                        self.log(f"    Find-links: {index_url}")
+                        self.log(f"    Package: {pkg_spec}")
+                        result = subprocess.run(
+                            pip_args + ["--find-links", index_url, "--no-deps", pkg_spec],
+                            capture_output=True, text=True,
+                        )
 
                 elif method == "pypi_variant":
                     # Transform package name based on CUDA version

comfy_env-0.0.33/src/comfy_env/index_resolver.py

@@ -0,0 +1,132 @@
+"""
+Simple index resolver for finding wheel URLs from PEP 503 indexes.
+
+This module fetches and parses simple index HTML to find the exact wheel URL
+for a package given the runtime environment (CUDA, torch, python versions).
+"""
+
+import re
+import urllib.request
+from typing import Optional, Dict
+from urllib.parse import urljoin
+
+
+def resolve_wheel_from_index(
+    index_url: str,
+    package: str,
+    vars_dict: Dict[str, str],
+    version: Optional[str] = None,
+) -> Optional[str]:
+    """
+    Resolve the exact wheel URL from a PEP 503 simple index or find-links page.
+
+    Args:
+        index_url: Base URL of the simple index (e.g., https://pozzettiandrea.github.io/cuda-wheels)
+                   or find-links page (e.g., https://data.pyg.org/whl/torch-2.8.0+cu128.html)
+        package: Package name (e.g., "cumesh")
+        vars_dict: Environment variables dict with cuda_short, torch_mm, py_tag, platform
+        version: Specific version to match, or None for latest
+
+    Returns:
+        Full wheel URL if found, None otherwise
+    """
+    # PEP 503: normalize package name (lowercase, replace _ with -)
+    normalized = package.lower().replace("_", "-")
+
+    # Try two URL patterns:
+    # 1. PEP 503 index: {index_url}/{package}/
+    # 2. Find-links page: {index_url} directly (e.g., .html file)
+    urls_to_try = []
+
+    if index_url.endswith('.html'):
+        # Direct HTML page (find-links style)
+        urls_to_try = [index_url]
+    else:
+        # PEP 503 style - try package subdirectory first, then root
+        urls_to_try = [
+            f"{index_url.rstrip('/')}/{normalized}/",
+            index_url,
+        ]
+
+    html = None
+    base_url = None
+    for url in urls_to_try:
+        try:
+            with urllib.request.urlopen(url, timeout=10) as response:
+                html = response.read().decode('utf-8')
+                base_url = url
+                break
+        except Exception:
+            continue
+
+    if not html:
+        return None
+
+    # Extract wheel links from HTML
+    # Simple index format: <a href="...">wheel_filename</a>
+    wheel_pattern = re.compile(r'<a[^>]+href="([^"]+\.whl)"[^>]*>([^<]+)</a>', re.IGNORECASE)
+    wheels = wheel_pattern.findall(html)
+
+    if not wheels:
+        return None
+
+    # Build matching criteria from vars_dict
+    cuda_short = vars_dict.get("cuda_short", "")
+    torch_mm = vars_dict.get("torch_mm", "")
+    py_tag = vars_dict.get("py_tag", "")
+    platform = vars_dict.get("platform", "")
+
+    # Find matching wheel
+    # Wheel filename format: {package}-{version}+cu{cuda}torch{torch}-{pytag}-{pytag}-{platform}.whl
+    best_match = None
+    best_version = None
+
+    for href, filename in wheels:
+        # Check if wheel matches our environment
+        if cuda_short and f"cu{cuda_short}" not in filename.lower():
+            continue
+        if torch_mm and f"torch{torch_mm}" not in filename.lower():
+            continue
+        if py_tag and py_tag not in filename:
+            continue
+        if platform and platform not in filename:
+            continue
+
+        # Extract version from filename
+        # Format: package-version+... or package-version-...
+        # Package name in wheel can use underscore or hyphen interchangeably
+        pkg_pattern = re.escape(package).replace(r'\_', '[-_]').replace(r'\-', '[-_]')
+        norm_pattern = re.escape(normalized).replace(r'\_', '[-_]').replace(r'\-', '[-_]')
+        match = re.match(rf'{pkg_pattern}[-_]([^+\-]+)', filename, re.IGNORECASE)
+        if not match:
+            # Try with normalized name
+            match = re.match(rf'{norm_pattern}[-_]([^+\-]+)', filename, re.IGNORECASE)
+
+        if match:
+            wheel_version = match.group(1)
+
+            # If specific version requested, must match
+            if version and version != "*" and wheel_version != version:
+                continue
+
+            # Track best (highest) version
+            if best_version is None or _version_gt(wheel_version, best_version):
+                best_version = wheel_version
+                # Resolve relative URL
+                if href.startswith('http'):
+                    best_match = href
+                else:
+                    best_match = urljoin(base_url, href)
+
+    return best_match
+
+
+def _version_gt(v1: str, v2: str) -> bool:
+    """Compare version strings (simple comparison)."""
+    try:
+        # Split into parts and compare numerically
+        parts1 = [int(x) for x in re.split(r'[.\-+]', v1) if x.isdigit()]
+        parts2 = [int(x) for x in re.split(r'[.\-+]', v2) if x.isdigit()]
+        return parts1 > parts2
+    except (ValueError, AttributeError):
+        return v1 > v2

{comfy_env-0.0.31 → comfy_env-0.0.33}/src/comfy_env/install.py

@@ -31,6 +31,7 @@ from .errors import CUDANotFoundError, DependencyError, InstallError, WheelNotFo
 from .pixi import pixi_install
 from .registry import PACKAGE_REGISTRY, get_cuda_short2
 from .resolver import RuntimeEnv, WheelResolver, parse_wheel_requirement
+from .index_resolver import resolve_wheel_from_index
 
 
 def _install_system_packages(
@@ -474,7 +475,7 @@ def _install_cuda_package(
         method = config["method"]
 
         if method == "index":
-            # PEP 503 index - use pip --extra-index-url
+            # PEP 503 index - try to resolve exact wheel URL first
             index_url = _substitute_template(config["index_url"], env)
             # Check for version_template (e.g., detectron2 with embedded torch/cuda version)
             if "version_template" in config:
@@ -483,27 +484,55 @@ def _install_cuda_package(
             else:
                 pkg_spec = f"{package}=={version}" if version else package
             log(f"  Installing {package} (index)...")
-            log(f"    Index: {index_url}")
-            log(f"    Package: {pkg_spec}")
-            _pip_install_with_index(pkg_spec, index_url, log)
+            # Try to resolve exact wheel URL from index
+            actual_version = resolved_version if "version_template" in config else version
+            vars_dict = env.as_dict()
+            wheel_url = resolve_wheel_from_index(index_url, package, vars_dict, actual_version)
+            if wheel_url:
+                # Install from resolved URL directly (guarantees we get what we resolved)
+                log(f"    Wheel: {wheel_url}")
+                _pip_install([wheel_url], no_deps=True, log=log)
+            else:
+                # Fallback to index-based resolution
+                log(f"    Index: {index_url}")
+                log(f"    Package: {pkg_spec}")
+                _pip_install_with_index(pkg_spec, index_url, log)
 
         elif method == "github_index":
-            # GitHub Pages index - use pip --find-links
+            # GitHub Pages index - try to resolve exact wheel URL first
             index_url = _substitute_template(config["index_url"], env)
             pkg_spec = f"{package}=={version}" if version else package
             log(f"  Installing {package} (github_index)...")
-            log(f"    Find-links: {index_url}")
-            log(f"    Package: {pkg_spec}")
-            _pip_install_with_find_links(pkg_spec, index_url, log)
+            # Try to resolve exact wheel URL from find-links page
+            vars_dict = env.as_dict()
+            wheel_url = resolve_wheel_from_index(index_url, package, vars_dict, version)
+            if wheel_url:
+                # Install from resolved URL directly (guarantees we get what we resolved)
+                log(f"    Wheel: {wheel_url}")
+                _pip_install([wheel_url], no_deps=True, log=log)
+            else:
+                # Fallback to find-links based resolution
+                log(f"    Find-links: {index_url}")
+                log(f"    Package: {pkg_spec}")
+                _pip_install_with_find_links(pkg_spec, index_url, log)
 
         elif method == "find_links":
-            # Generic find-links (e.g., PyG) - use pip --find-links
+            # Generic find-links (e.g., PyG) - try to resolve exact wheel URL first
             index_url = _substitute_template(config["index_url"], env)
             pkg_spec = f"{package}=={version}" if version else package
             log(f"  Installing {package} (find_links)...")
-            log(f"    Find-links: {index_url}")
-            log(f"    Package: {pkg_spec}")
-            _pip_install_with_find_links(pkg_spec, index_url, log)
+            # Try to resolve exact wheel URL from find-links page
+            vars_dict = env.as_dict()
+            wheel_url = resolve_wheel_from_index(index_url, package, vars_dict, version)
+            if wheel_url:
+                # Install from resolved URL directly (guarantees we get what we resolved)
+                log(f"    Wheel: {wheel_url}")
+                _pip_install([wheel_url], no_deps=True, log=log)
+            else:
+                # Fallback to find-links based resolution
+                log(f"    Find-links: {index_url}")
+                log(f"    Package: {pkg_spec}")
+                _pip_install_with_find_links(pkg_spec, index_url, log)
 
         elif method == "pypi_variant":
             # Transform package name based on CUDA version

{comfy_env-0.0.31 → comfy_env-0.0.33}/src/comfy_env/wheel_sources.yml

@@ -60,50 +60,60 @@ packages:
   # ===========================================================================
   # PozzettiAndrea cuda-wheels (unified PEP 503 index)
   # https://pozzettiandrea.github.io/cuda-wheels
+  # Wheel naming: {package}-{version}+cu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl
   # ===========================================================================
   nvdiffrast:
     method: index
     index_url: "https://pozzettiandrea.github.io/cuda-wheels"
+    wheel_template: "https://pozzettiandrea.github.io/cuda-wheels/nvdiffrast/nvdiffrast-{version}%2Bcu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl"
     description: NVIDIA differentiable rasterizer
 
   cumesh:
     method: index
     index_url: "https://pozzettiandrea.github.io/cuda-wheels"
+    wheel_template: "https://pozzettiandrea.github.io/cuda-wheels/cumesh/cumesh-{version}%2Bcu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl"
     description: CUDA-accelerated mesh utilities
 
   o_voxel:
     method: index
     index_url: "https://pozzettiandrea.github.io/cuda-wheels"
+    wheel_template: "https://pozzettiandrea.github.io/cuda-wheels/o-voxel/o_voxel-{version}%2Bcu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl"
     description: O-Voxel CUDA extension for TRELLIS
 
   flex_gemm:
     method: index
     index_url: "https://pozzettiandrea.github.io/cuda-wheels"
+    wheel_template: "https://pozzettiandrea.github.io/cuda-wheels/flex-gemm/flex_gemm-{version}%2Bcu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl"
     description: Flexible GEMM operations
 
   nvdiffrec_render:
     method: index
     index_url: "https://pozzettiandrea.github.io/cuda-wheels"
+    wheel_template: "https://pozzettiandrea.github.io/cuda-wheels/nvdiffrec-render/nvdiffrec_render-{version}%2Bcu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl"
     description: NVDiffRec rendering utilities
 
   gsplat:
     method: index
     index_url: "https://pozzettiandrea.github.io/cuda-wheels"
+    wheel_template: "https://pozzettiandrea.github.io/cuda-wheels/gsplat/gsplat-{version}%2Bcu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl"
     description: Gaussian splatting rasterization
 
   cc_torch:
     method: index
     index_url: "https://pozzettiandrea.github.io/cuda-wheels"
+    wheel_template: "https://pozzettiandrea.github.io/cuda-wheels/cc-torch/cc_torch-{version}%2Bcu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl"
     description: GPU-accelerated connected components
 
   torch_generic_nms:
     method: index
     index_url: "https://pozzettiandrea.github.io/cuda-wheels"
+    wheel_template: "https://pozzettiandrea.github.io/cuda-wheels/torch-generic-nms/torch_generic_nms-{version}%2Bcu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl"
     description: GPU-accelerated Non-Maximum Suppression
 
   lietorch:
     method: index
     index_url: "https://pozzettiandrea.github.io/cuda-wheels"
+    wheel_template: "https://pozzettiandrea.github.io/cuda-wheels/lietorch/lietorch-{version}%2Bcu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl"
     description: Lie group operations for PyTorch (DPVO dependency)
 
   # ===========================================================================