comfy-env 0.0.40__py3-none-any.whl → 0.0.42__py3-none-any.whl

{comfy_env-0.0.40.dist-info → comfy_env-0.0.42.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.40
+Version: 0.0.42
 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
@@ -67,17 +67,12 @@ curl -LsSf https://astral.sh/uv/install.sh | sh
 Create a `comfy-env.toml` in your node directory:
 
 ```toml
-[env]
-name = "my-node"
-python = "3.10"
-cuda = "auto"
+[cuda]
+nvdiffrast = "0.4.0"
+pytorch3d = "0.7.9"
 
 [packages]
 requirements = ["transformers>=4.56", "pillow"]
-no_deps = ["nvdiffrast==0.4.0", "pytorch3d>=0.7.8"]
-
-[sources]
-wheel_sources = ["https://github.com/PozzettiAndrea/nvdiffrast-full-wheels/releases/download/"]
 ```
 
 Then in your `__init__.py`:
@@ -122,56 +117,124 @@ comfy-env install --dry-run
 # Resolve wheel URLs without installing
 comfy-env resolve nvdiffrast==0.4.0
 
+# List all packages in the built-in registry
+comfy-env list-packages
+
 # Verify installation
 comfy-env doctor
 ```
 
-## Configurations
+## Configuration
 
-### comfy-env.toml
+### Simple Format (comfy-env.toml)
 
 ```toml
-[env]
-name = "my-node"          # Unique name for caching
-python = "3.10"           # Python version
-cuda = "auto"             # "auto", "12.8", "12.4", or null
+# CUDA packages (uses built-in registry)
+[cuda]
+nvdiffrast = "0.4.0"
+pytorch3d = "0.7.9"
+torch-scatter = "2.1.2"
 
+# Regular pip packages
 [packages]
-requirements = [          # Regular pip packages
-    "transformers>=4.56",
-    "pillow",
-]
-no_deps = [               # CUDA packages (installed with --no-deps)
-    "nvdiffrast==0.4.0",
-    "pytorch3d>=0.7.8",
-]
-
-[sources]
-wheel_sources = [         # GitHub releases with pre-built wheels
-    "https://github.com/.../releases/download/",
-]
-index_urls = [            # Extra pip index URLs
-    "https://pypi.org/simple/",
-]
-
-[worker]                  # For isolation mode
-package = "worker"        # worker/__main__.py
+requirements = ["transformers>=4.56", "pillow"]
 ```
 
-### Template Variables
+### Full Format
+
+```toml
+[system]
+linux = ["libgl1", "libopengl0"]  # apt packages
+
+[local.cuda]
+nvdiffrast = "0.4.0"
+
+[local.packages]
+requirements = ["pillow", "numpy"]
+
+# For isolated environments (creates separate venv)
+[myenv]
+python = "3.10"
+cuda = "12.8"
+
+[myenv.cuda]
+torch-scatter = "2.1.2"
 
-Wheel URLs support these template variables:
+[myenv.packages]
+requirements = ["transformers>=4.56"]
+
+# Custom wheel templates (override built-in registry)
+[wheel_sources]
+my-custom-pkg = "https://my-server.com/my-pkg-{version}+cu{cuda_short}-{py_tag}-{platform}.whl"
+```
+
+## Writing Wheel Templates
+
+### Template Variables
 
 | Variable | Example | Description |
 |----------|---------|-------------|
+| `{version}` | `0.4.0` | Package version |
 | `{cuda_version}` | `12.8` | Full CUDA version |
 | `{cuda_short}` | `128` | CUDA without dot |
-| `{torch_version}` | `2.8.0` | PyTorch version |
-| `{torch_mm}` | `28` | PyTorch major.minor |
+| `{cuda_major}` | `12` | CUDA major only |
+| `{torch_version}` | `2.8.0` | Full PyTorch version |
+| `{torch_mm}` | `28` | PyTorch major.minor no dot |
+| `{torch_dotted_mm}` | `2.8` | PyTorch major.minor with dot |
 | `{py_version}` | `3.10` | Python version |
 | `{py_short}` | `310` | Python without dot |
+| `{py_tag}` | `cp310` | Python wheel tag |
 | `{platform}` | `linux_x86_64` | Platform tag |
 
+### Common Wheel URL Patterns
+
+**Pattern 1: Simple CUDA + Python**
+```
+https://example.com/{package}-{version}+cu{cuda_short}-{py_tag}-{py_tag}-{platform}.whl
+```
+
+**Pattern 2: CUDA + PyTorch**
+```
+https://example.com/{package}-{version}+cu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl
+```
+
+**Pattern 3: GitHub Releases**
+```
+https://github.com/org/repo/releases/download/v{version}/{package}-{version}+cu{cuda_short}-{py_tag}-{platform}.whl
+```
+
+### How to Find the Right Template
+
+1. Download a wheel manually from the source
+2. Look at the filename pattern: `nvdiffrast-0.4.0+cu128torch28-cp310-cp310-linux_x86_64.whl`
+3. Replace values with variables: `nvdiffrast-{version}+cu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl`
+4. Prepend the base URL
+
+### Testing Your Template
+
+```bash
+comfy-env resolve my-package==1.0.0
+```
+
+This shows the resolved URL without installing.
+
+### Adding Custom Wheel Sources
+
+If a package isn't in the built-in registry, add it to your `comfy-env.toml`:
+
+```toml
+[cuda]
+my-custom-pkg = "1.0.0"
+
+[wheel_sources]
+my-custom-pkg = "https://my-server.com/my-custom-pkg-{version}+cu{cuda_short}-{py_tag}-{platform}.whl"
+```
+
+Resolution order:
+1. User's `[wheel_sources]` in comfy-env.toml (highest priority)
+2. Built-in `wheel_sources.yml` registry
+3. Error if not found
+
 ## API Reference
 
 ### install()
@@ -185,23 +248,22 @@ install()
 # Explicit config
 install(config="comfy-env.toml")
 
-# Isolated mode (creates separate venv)
-install(mode="isolated")
-
 # Dry run
 install(dry_run=True)
 ```
 
-### WheelResolver
+### RuntimeEnv
 
 ```python
-from comfy_env import RuntimeEnv, WheelResolver
+from comfy_env import RuntimeEnv
 
 env = RuntimeEnv.detect()
-resolver = WheelResolver()
+print(env)
+# Python 3.10, CUDA 12.8, PyTorch 2.8.0, GPU: NVIDIA GeForce RTX 4090
 
-url = resolver.resolve("nvdiffrast", "0.4.0", env)
-print(url)  # https://github.com/.../nvdiffrast-0.4.0+cu128torch28-...whl
+# Get template variables
+vars_dict = env.as_dict()
+# {'cuda_version': '12.8', 'cuda_short': '128', 'torch_mm': '28', ...}
 ```
 
 ### Workers (for isolation)
@@ -224,6 +286,16 @@ print(get_gpu_summary())
 # GPU 0: NVIDIA GeForce RTX 5090 (sm_120) [Blackwell - CUDA 12.8]
 ```
 
+## Built-in Package Registry
+
+Run `comfy-env list-packages` to see all packages in the built-in registry.
+
+The registry includes:
+- PyTorch Geometric packages (torch-scatter, torch-cluster, torch-sparse)
+- NVIDIA packages (nvdiffrast, pytorch3d, gsplat)
+- Flash Attention (flash-attn)
+- And more
+
 ## License
 
 MIT - see LICENSE file.

{comfy_env-0.0.40.dist-info → comfy_env-0.0.42.dist-info}/RECORD

@@ -1,18 +1,17 @@
-comfy_env/__init__.py,sha256=PCx-J6DaolN2TEQ90YfhKMV_Kdd2BK2rxlnhVa7SQFc,3685
-comfy_env/cli.py,sha256=X-GCQMP0mtMcE3ZgkT-VLQ4Gq3UUvcb_Ux_NClEFhgI,15975
+comfy_env/__init__.py,sha256=OQJFNjmArjLcgrfHAFxgDJQFH_IhxibqMXbU5bu_j9Q,3822
+comfy_env/cli.py,sha256=hZv_oJsmaMoG62Fr2Fjp778P_32BHr4fzS7G4lULSwU,13153
 comfy_env/decorator.py,sha256=6JCKwLHaZtOLVDexs_gh_-NtS2ZK0V7nGCPqkyeYEAA,16688
 comfy_env/errors.py,sha256=8hN8NDlo8oBUdapc-eT3ZluigI5VBzfqsSBvQdfWlz4,9943
-comfy_env/index_resolver.py,sha256=D8BttTJ7BOiukUvmdT6_dGdzFV3CahGL2m28X-HwPeE,4650
-comfy_env/install.py,sha256=Az72DmrDpyD9KZ8KUK1nna7v19jjPVQXGSncSeAkNSY,32320
+comfy_env/install.py,sha256=0wz4i19BbNAhfK-bK77LPabheOYhpfBgZFOLWsqKPPY,16329
 comfy_env/nodes.py,sha256=CWUe35jU5SKk4ur-SddZePdqWgxJDlxGhpcJiu5pAK4,4354
 comfy_env/pixi.py,sha256=y25mUDhB3bCqhPMGF0h23Tf8ZHykK4gLJrkvOhsPWmE,14398
-comfy_env/registry.py,sha256=uFCtGmWYvwGCqObXgzmArX7o5JsFNsHXxayofk3m6no,2569
-comfy_env/resolver.py,sha256=l-AnmCE1puG6CvdpDB-KrsfG_cn_3uO2DryYizUnG_4,12474
+comfy_env/registry.py,sha256=w-QwvAPFlCrBYRAv4cXkp2zujQPZn8Fk5DUxKCtox8o,3430
+comfy_env/resolver.py,sha256=WoNIo2IfTR2RlEf_HQl66eAeMa2R2pmLof_UdK-0RNE,6714
 comfy_env/env/__init__.py,sha256=imQdoQEQvrRT-QDtyNpFlkVbm2fBzgACdpQwRPd09fI,1157
-comfy_env/env/config.py,sha256=5rK7r2uRItMXJnKAn8DmVQoadLo2njHTuaxrWybhppU,7469
-comfy_env/env/config_file.py,sha256=1UdcL1TwKceGaSunCnsHiuPyxpCSq1JpelScUEsCBn8,23669
+comfy_env/env/config.py,sha256=Ila-5Yal3bj6jENbBeYJlZtkbgdwnzJzImVZK3ZF1lg,7645
+comfy_env/env/config_file.py,sha256=HzFKeQh9zQ--K1V-XuvgE6DiE_bYrXrChL1ZT8Tzlq4,24684
 comfy_env/env/cuda_gpu_detection.py,sha256=YLuXUdWg6FeKdNyLlQAHPlveg4rTenXJ2VbeAaEi9QE,9755
-comfy_env/env/manager.py,sha256=wv_od7Rxa-qMlToUGzOhAsDvZY6C0P7y9ayqYiKKLPg,26460
+comfy_env/env/manager.py,sha256=eDcrtJeNrW3jYb0q0R_DmUfAYjGo5Cs4BMuZUxWEzeg,21789
 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
@@ -37,9 +36,9 @@ comfy_env/workers/pool.py,sha256=MtjeOWfvHSCockq8j1gfnxIl-t01GSB79T5N4YB82Lg,695
 comfy_env/workers/tensor_utils.py,sha256=TCuOAjJymrSbkgfyvcKtQ_KbVWTqSwP9VH_bCaFLLq8,6409
 comfy_env/workers/torch_mp.py,sha256=4YSNPn7hALrvMVbkO4RkTeFTcc0lhfLMk5QTWjY4PHw,22134
 comfy_env/workers/venv.py,sha256=PmsVOu5i89tBYkGRupo2bjOLPBmk06q4GNUwDWsd9F8,32088
-comfy_env/wheel_sources.yml,sha256=IEyi3JnySo4sXTRkYR0VjtCdXaCsF5Q5c0nU0S9LC8I,9143
-comfy_env-0.0.40.dist-info/METADATA,sha256=eJYprZ_ULUXc7vWu10nqRaMntOuerWRSJpBYf4zXUwc,5400
-comfy_env-0.0.40.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.0.40.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.0.40.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.0.40.dist-info/RECORD,,
+comfy_env/wheel_sources.yml,sha256=B8HIRuakB68oD3bcGBJPnrCnAFkP5FMPaDotUX4-2TY,7278
+comfy_env-0.0.42.dist-info/METADATA,sha256=KLuQlF5nxK_DSEoVWlBU7kfaGtiXr26-8jokF_8FmSA,7138
+comfy_env-0.0.42.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.0.42.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.0.42.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.0.42.dist-info/RECORD,,

comfy_env/index_resolver.py

@@ -1,132 +0,0 @@
-"""
-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