comfy-env 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

comfy_env/isolation/wrap.py

@@ -319,6 +319,13 @@ def wrap_isolated_nodes(
     if os.environ.get("COMFYUI_ISOLATION_WORKER") == "1":
         return node_class_mappings
 
+    # Get ComfyUI base path from folder_paths (canonical source)
+    try:
+        import folder_paths
+        comfyui_base = folder_paths.base_path
+    except ImportError:
+        comfyui_base = None
+
     nodes_dir = Path(nodes_dir).resolve()
 
     # Check for comfy-env.toml
@@ -341,6 +348,10 @@ def wrap_isolated_nodes(
     except Exception:
         pass  # Ignore errors reading config
 
+    # Set COMFYUI_BASE for worker to find ComfyUI modules
+    if comfyui_base:
+        env_vars["COMFYUI_BASE"] = str(comfyui_base)
+
     # Find environment directory and paths
     env_dir = _find_env_dir(nodes_dir)
     site_packages, lib_dir = _find_env_paths(nodes_dir)

comfy_env/nodes.py

@@ -71,6 +71,31 @@ def clone_node(
     return node_path
 
 
+def install_requirements(
+    node_dir: Path,
+    log: Callable[[str], None],
+) -> None:
+    """
+    Install requirements.txt in a node directory if it exists.
+
+    Args:
+        node_dir: Path to the node directory
+        log: Logging callback
+    """
+    requirements_file = node_dir / "requirements.txt"
+
+    if requirements_file.exists():
+        log(f"  Installing requirements for {node_dir.name}...")
+        result = subprocess.run(
+            ["uv", "pip", "install", "-r", str(requirements_file), "--python", sys.executable],
+            cwd=node_dir,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            log(f"  Warning: requirements.txt install failed for {node_dir.name}: {result.stderr.strip()[:200]}")
+
+
 def run_install_script(
     node_dir: Path,
     log: Callable[[str], None],
@@ -132,6 +157,9 @@ def install_node_deps(
             # Clone the repository
             clone_node(req.repo, req.name, custom_nodes_dir, log)
 
+            # Install requirements.txt if present
+            install_requirements(node_path, log)
+
             # Run install.py if present
             run_install_script(node_path, log)
 

comfy_env/pixi/core.py

@@ -40,10 +40,87 @@ CUDA_TORCH_MAP = {
     "12.1": "2.4",
 }
 
+def find_wheel_url(
+    package: str,
+    torch_version: str,
+    cuda_version: str,
+    python_version: str,
+) -> Optional[str]:
+    """
+    Query cuda-wheels index and return the direct URL for the matching wheel.
+
+    This bypasses pip's version validation by providing a direct URL,
+    which is necessary for wheels where the filename has a local version
+    but the internal METADATA doesn't (e.g., flash-attn from mjun0812).
+
+    Args:
+        package: Package name (e.g., "flash-attn")
+        torch_version: PyTorch version (e.g., "2.8")
+        cuda_version: CUDA version (e.g., "12.8")
+        python_version: Python version (e.g., "3.10")
+
+    Returns:
+        Direct URL to the wheel file, or None if no match found.
+    """
+    cuda_short = cuda_version.replace(".", "")[:3]  # "12.8" -> "128"
+    torch_short = torch_version.replace(".", "")[:2]  # "2.8" -> "28"
+    py_tag = f"cp{python_version.replace('.', '')}"  # "3.10" -> "cp310"
+
+    # Platform tag for current system
+    if sys.platform == "linux":
+        platform_tag = "linux_x86_64"
+    elif sys.platform == "win32":
+        platform_tag = "win_amd64"
+    else:
+        platform_tag = None  # macOS doesn't typically have CUDA wheels
+
+    # Local version patterns to match:
+    # cuda-wheels style: +cu128torch28
+    # PyG style: +pt28cu128
+    local_patterns = [
+        f"+cu{cuda_short}torch{torch_short}",  # cuda-wheels style
+        f"+pt{torch_short}cu{cuda_short}",     # PyG style
+    ]
+
+    pkg_variants = [package, package.replace("-", "_"), package.replace("_", "-")]
+
+    for pkg_dir in pkg_variants:
+        index_url = f"{CUDA_WHEELS_INDEX}{pkg_dir}/"
+        try:
+            with urllib.request.urlopen(index_url, timeout=10) as resp:
+                html = resp.read().decode("utf-8")
+        except Exception:
+            continue
+
+        # Parse href and display name from HTML: <a href="URL">DISPLAY_NAME</a>
+        link_pattern = re.compile(r'href="([^"]+\.whl)"[^>]*>([^<]+)</a>', re.IGNORECASE)
+
+        for match in link_pattern.finditer(html):
+            wheel_url = match.group(1)
+            display_name = match.group(2)
+
+            # Match on display name (has normalized torch28 format)
+            matches_cuda_torch = any(p in display_name for p in local_patterns)
+            matches_python = py_tag in display_name
+            matches_platform = platform_tag is None or platform_tag in display_name
+
+            if matches_cuda_torch and matches_python and matches_platform:
+                # Return absolute URL
+                if wheel_url.startswith("http"):
+                    return wheel_url
+                # Relative URL - construct absolute
+                return f"{CUDA_WHEELS_INDEX}{pkg_dir}/{wheel_url}"
+
+    return None
+
+
 def find_matching_wheel(package: str, torch_version: str, cuda_version: str) -> Optional[str]:
     """
     Query cuda-wheels index to find a wheel matching the CUDA/torch version.
     Returns the full version spec (e.g., "flash-attn===2.8.3+cu128torch2.8") or None.
+
+    Note: This is used as a fallback for packages with correct wheel metadata.
+    For packages with mismatched metadata (like flash-attn), use find_wheel_url() instead.
     """
     cuda_short = cuda_version.replace(".", "")[:3]  # "12.8" -> "128"
     torch_short = torch_version.replace(".", "")[:2]  # "2.8" -> "28"
@@ -67,11 +144,11 @@ def find_matching_wheel(package: str, torch_version: str, cuda_version: str) ->
         )
 
         # Local version patterns to match:
-        # flash-attn style: +cu128torch2.8
+        # cuda-wheels style: +cu128torch28
         # PyG style: +pt28cu128
         local_patterns = [
-            f"+cu{cuda_short}torch{torch_version}",  # flash-attn style
-            f"+pt{torch_short}cu{cuda_short}",       # PyG style
+            f"+cu{cuda_short}torch{torch_short}",  # cuda-wheels style
+            f"+pt{torch_short}cu{cuda_short}",     # PyG style
         ]
 
         best_match = None
@@ -394,29 +471,35 @@ def pixi_install(
         log(f"pixi install failed:\n{result.stderr}")
         raise RuntimeError(f"pixi install failed: {result.stderr}")
 
-    # Install CUDA packages with --find-links (searches all known sources)
+    # Install CUDA packages via direct URL or find-links fallback
     if cfg.cuda_packages and cuda_version:
         log(f"Installing CUDA packages: {cfg.cuda_packages}")
         python_path = get_pixi_python(node_dir)
         if not python_path:
             raise RuntimeError("Could not find Python in pixi environment")
 
+        # Get Python version from the pixi environment
+        py_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+
         for package in cfg.cuda_packages:
+            # Find direct wheel URL (bypasses metadata validation)
+            wheel_url = find_wheel_url(package, torch_version, cuda_version, py_version)
+
+            if not wheel_url:
+                raise RuntimeError(
+                    f"No wheel found for {package} with CUDA {cuda_version}, "
+                    f"torch {torch_version}, Python {py_version}. "
+                    f"Check cuda-wheels index."
+                )
+
+            log(f"  Installing {package} from {wheel_url}")
             pip_cmd = [
                 str(python_path), "-m", "pip", "install",
-                "--no-index",  # Only use --find-links, don't query PyPI
                 "--no-deps",
                 "--no-cache-dir",
+                wheel_url,
             ]
 
-            # Add all find-links sources
-            for url in get_all_find_links(package, torch_version, cuda_version):
-                pip_cmd.extend(["--find-links", url])
-
-            # Get package spec with local version for CUDA/torch compatibility
-            pkg_spec = get_package_spec(package, torch_version, cuda_version)
-            log(f"  Installing {pkg_spec}")
-            pip_cmd.append(pkg_spec)
             result = subprocess.run(pip_cmd, capture_output=True, text=True)
             if result.returncode != 0:
                 log(f"CUDA package install failed for {package}:\n{result.stderr}")

comfy_env/workers/subprocess.py

@@ -1044,15 +1044,21 @@ class SubprocessWorker(Worker):
 
     def _find_comfyui_base(self) -> Optional[Path]:
         """Find ComfyUI base directory."""
-        # Check common child directories (for test environments)
-        # Also check parent's children (isolated venv is sibling to .comfy-test-env)
+        # Use folder_paths.base_path (canonical source) if available
+        try:
+            import folder_paths
+            return Path(folder_paths.base_path)
+        except ImportError:
+            pass
+
+        # Fallback: Check common child directories (for test environments)
         for base in [self.working_dir, self.working_dir.parent]:
             for child in [".comfy-test-env/ComfyUI", "ComfyUI"]:
                 candidate = base / child
                 if (candidate / "main.py").exists() and (candidate / "comfy").exists():
                     return candidate
 
-        # Walk up from working_dir (standard ComfyUI custom_nodes layout)
+        # Fallback: Walk up from working_dir (standard ComfyUI custom_nodes layout)
         current = self.working_dir.resolve()
         for _ in range(10):
             if (current / "main.py").exists() and (current / "comfy").exists():

{comfy_env-0.1.8.dist-info → comfy_env-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.1.8
+Version: 0.1.9
 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: pip>=21.0
 Requires-Dist: tomli-w>=1.0.0
 Requires-Dist: tomli>=2.0.0; python_version < '3.11'
 Requires-Dist: uv>=0.4.0

{comfy_env-0.1.8.dist-info → comfy_env-0.1.9.dist-info}/RECORD

@@ -2,15 +2,15 @@ comfy_env/__init__.py,sha256=s0RkyKsBlDiSI4ZSwivtWLvYhc8DS0CUEWgFLVJbtLA,2176
 comfy_env/cli.py,sha256=ty4HYlzollCUCS0o6Sha6eczPAsW_gHRVgvck3IfA2w,12723
 comfy_env/errors.py,sha256=q-C3vyrPa_kk_Ao8l17mIGfJiG2IR0hCFV0GFcNLmcI,9924
 comfy_env/install.py,sha256=N7eBj8wB2DrGepVYk-Hks2mSf6UuGzj34pfVLNYJgQ4,10357
-comfy_env/nodes.py,sha256=nBkG2pESeOt5kXSgTDIHAHaVdHK8-rEueR3BxXWn6TE,4354
+comfy_env/nodes.py,sha256=nR-LctovXYTqk-seHovq9W_Ll0hlLeGMw-SQsa6IkBM,5235
 comfy_env/prestartup.py,sha256=NML_nzg4h37YdEg7gHxA7ke_uXWZsldz-X3HldHEUsE,5338
 comfy_env/config/__init__.py,sha256=4Guylkb-FV8QxhFwschzpzbr2eu8y-KNgNT3_JOm9jc,403
 comfy_env/config/parser.py,sha256=dA1lX5ExBEfCqUJwe4V5i_jn2NJ69bMq3c3ji3lMSV8,4295
 comfy_env/config/types.py,sha256=Sb8HO34xsSZu5YAc2K4M7Gb3QNevJlngf12hHiwuU0w,2140
 comfy_env/isolation/__init__.py,sha256=vw9a4mpJ2CFjy-PLe_A3zQ6umBQklgqWNxwn9beNw3g,175
-comfy_env/isolation/wrap.py,sha256=NACfz-EmKj6X5Ko6dshYjS-jUm-q8xm7uZWpr52858Y,12307
+comfy_env/isolation/wrap.py,sha256=fYsf3tWpzNPoZT7mvWHbD-LmgBMhMCIfzlfcOFgwhlU,12641
 comfy_env/pixi/__init__.py,sha256=BUrq7AQf3WDm0cHWh72B2xZbURNnDu2dCuELWiQCUiM,997
-comfy_env/pixi/core.py,sha256=SO4v68-Lvrt6Z60j6jt91bLPGieF1wi43Uuq5F77Vv4,15627
+comfy_env/pixi/core.py,sha256=zPEtuF8D2gnIaljmGEGT8Ttw0lTy_cV-hIIn1fvlbBU,18788
 comfy_env/pixi/cuda_detection.py,sha256=sqB3LjvGNdV4eFqiARQGfyecBM3ZiUmeh6nG0YCRYQw,9751
 comfy_env/pixi/resolver.py,sha256=U_A8rBDxCj4gUlJt2YJQniP4cCKqxJEiVFgXOoH7vM8,6339
 comfy_env/pixi/platform/__init__.py,sha256=Nb5MPZIEeanSMEWwqU4p4bnEKTJn1tWcwobnhq9x9IY,614
@@ -23,10 +23,10 @@ comfy_env/templates/comfy-env.toml,sha256=ROIqi4BlPL1MEdL1VgebfTHpdwPNYGHwWeigI9
 comfy_env/workers/__init__.py,sha256=TMVG55d2XLP1mJ3x1d16H0SBDJZtk2kMC5P4HLk9TrA,1073
 comfy_env/workers/base.py,sha256=4ZYTaQ4J0kBHCoO_OfZnsowm4rJCoqinZUaOtgkOPbw,2307
 comfy_env/workers/mp.py,sha256=8Xqcr4R4KlHtP1P_UDAtSTPHA_5i-ySTlxxLpqyOk-w,29757
-comfy_env/workers/subprocess.py,sha256=UMhKhaJoSjv2-FWnwQq9TeMWtaDLIs3ajAFTq1ngdJw,57844
+comfy_env/workers/subprocess.py,sha256=a9gpaTppbL7ZRgv4grK__QioGUiN0Ci9RIZGTVTsQ78,57993
 comfy_env/workers/tensor_utils.py,sha256=TCuOAjJymrSbkgfyvcKtQ_KbVWTqSwP9VH_bCaFLLq8,6409
-comfy_env-0.1.8.dist-info/METADATA,sha256=8WOllc7KtZ1wb3pkCam0qZd5YW1CEd33WwQIzBqENJI,6945
-comfy_env-0.1.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.1.8.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.1.8.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.1.8.dist-info/RECORD,,
+comfy_env-0.1.9.dist-info/METADATA,sha256=qplbcTtKJj8y2m8rGUpIMcZyZymKdqA7wQNQf4t5HsI,6970
+comfy_env-0.1.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.1.9.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.1.9.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.1.9.dist-info/RECORD,,