comfy-env 0.0.56__tar.gz → 0.0.58__tar.gz

{comfy_env-0.0.56 → comfy_env-0.0.58}/PKG-INFO

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

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

{comfy_env-0.0.56 → comfy_env-0.0.58}/src/comfy_env/pixi.py

@@ -181,6 +181,97 @@ def _parse_pypi_requirement(dep: str) -> Tuple[str, Optional[str], List[str]]:
     return name, version_spec, extras
 
 
+def _build_cuda_vars(env_config: IsolatedEnv) -> dict:
+    """
+    Build variable dict for CUDA wheel URL resolution.
+
+    Returns a dict with CUDA, PyTorch, Python, and platform variables
+    for template substitution.
+    """
+    # Use fixed CUDA 12.8 / PyTorch 2.8 for pixi environments (modern GPU default)
+    vars_dict = {
+        "cuda_version": "12.8",
+        "cuda_short": "128",
+        "cuda_short2": "128",
+        "cuda_major": "12",
+        "torch_version": "2.8.0",
+        "torch_short": "280",
+        "torch_mm": "28",
+        "torch_dotted_mm": "2.8",
+    }
+
+    # Platform detection
+    if sys.platform == "linux":
+        vars_dict["platform"] = "linux_x86_64"
+    elif sys.platform == "darwin":
+        vars_dict["platform"] = "macosx_arm64" if platform.machine() == "arm64" else "macosx_x86_64"
+    elif sys.platform == "win32":
+        vars_dict["platform"] = "win_amd64"
+
+    # Python version from env config
+    if env_config.python:
+        py_parts = env_config.python.split(".")
+        py_major = py_parts[0]
+        py_minor = py_parts[1] if len(py_parts) > 1 else "0"
+        vars_dict["py_version"] = env_config.python
+        vars_dict["py_short"] = f"{py_major}{py_minor}"
+        vars_dict["py_minor"] = py_minor
+        vars_dict["py_tag"] = f"cp{py_major}{py_minor}"
+
+    return vars_dict
+
+
+def _resolve_cuda_wheel_url(
+    req: str,
+    vars_dict: dict,
+    log: Callable[[str], None] = print,
+) -> Optional[str]:
+    """
+    Resolve a CUDA package requirement to a wheel URL.
+
+    Args:
+        req: Package requirement (e.g., "cumesh" or "cumesh==0.0.1")
+        vars_dict: Variable dict for URL template substitution
+        log: Logging callback
+
+    Returns:
+        Resolved wheel URL, or None if package not in registry.
+    """
+    from .registry import PACKAGE_REGISTRY
+
+    # Parse requirement (e.g., "cumesh" or "cumesh==0.0.1")
+    if "==" in req:
+        pkg_name, version = req.split("==", 1)
+    else:
+        pkg_name = req
+        version = None
+
+    pkg_lower = pkg_name.lower()
+    if pkg_lower not in PACKAGE_REGISTRY:
+        log(f"  Warning: CUDA package {pkg_name} not in registry")
+        return None
+
+    config = PACKAGE_REGISTRY[pkg_lower]
+    template = config.get("wheel_template")
+    if not template:
+        log(f"  Warning: No wheel template for {pkg_name}")
+        return None
+
+    # Use version from requirement or default
+    v = version or config.get("default_version")
+    if v:
+        vars_dict = vars_dict.copy()  # Don't mutate original
+        vars_dict["version"] = v
+
+    # Resolve URL template
+    url = template
+    for key, value in vars_dict.items():
+        if value:
+            url = url.replace(f"{{{key}}}", str(value))
+
+    return url
+
+
 def create_pixi_toml(
     env_config: IsolatedEnv,
     node_dir: Path,
@@ -193,7 +284,11 @@ def create_pixi_toml(
     - Project metadata
     - Conda channels
     - Conda dependencies
-    - PyPI dependencies (from requirements + no_deps_requirements)
+    - PyPI dependencies (from requirements)
+
+    Note: CUDA packages (no_deps_requirements) are NOT included in pixi.toml.
+    They are installed separately with pip --no-deps after pixi install
+    to avoid transitive dependency conflicts.
 
     Args:
         env_config: The isolated environment configuration.
@@ -225,13 +320,13 @@ def create_pixi_toml(
     lines.append(f"channels = [{channels_str}]")
 
     # Platforms
+    # Note: On macOS we always use osx-64 (x86_64) even on ARM64 Macs.
+    # This runs under Rosetta 2 but ensures compatibility with packages
+    # that only have x86_64 wheels (e.g., embreex for trimesh raytracing).
     if sys.platform == "linux":
         lines.append('platforms = ["linux-64"]')
     elif sys.platform == "darwin":
-        if platform.machine() == "arm64":
-            lines.append('platforms = ["osx-arm64"]')
-        else:
-            lines.append('platforms = ["osx-64"]')
+        lines.append('platforms = ["osx-64"]')
     elif sys.platform == "win32":
         lines.append('platforms = ["win-64"]')
 
@@ -247,6 +342,7 @@ def create_pixi_toml(
     # Dependencies section (conda packages)
     lines.append("[dependencies]")
     lines.append(f'python = "{env_config.python}.*"')
+    lines.append('pip = "*"')  # Required for installing CUDA packages with --no-deps
 
     # On Windows, use MKL BLAS to avoid OpenBLAS crashes (numpy blas_fpe_check issue)
     if sys.platform == "win32":
@@ -312,67 +408,9 @@ def create_pixi_toml(
     if env_config.requirements:
         pypi_deps.extend(env_config.requirements)
 
-    # Add CUDA packages with resolved wheel URLs
-    if env_config.no_deps_requirements:
-        from .registry import PACKAGE_REGISTRY
-
-        # Use fixed CUDA 12.8 / PyTorch 2.8 for pixi environments (modern GPU default)
-        # This ensures wheels match what pixi will install, not what the host has
-        vars_dict = {
-            "cuda_version": "12.8",
-            "cuda_short": "128",
-            "cuda_short2": "128",
-            "cuda_major": "12",
-            "torch_version": "2.8.0",
-            "torch_short": "280",
-            "torch_mm": "28",
-            "torch_dotted_mm": "2.8",
-        }
-
-        # Platform detection
-        if sys.platform == "linux":
-            vars_dict["platform"] = "linux_x86_64"
-        elif sys.platform == "darwin":
-            vars_dict["platform"] = "macosx_arm64" if platform.machine() == "arm64" else "macosx_x86_64"
-        elif sys.platform == "win32":
-            vars_dict["platform"] = "win_amd64"
-
-        # Python version from pixi env config
-        if env_config.python:
-            py_parts = env_config.python.split(".")
-            py_major = py_parts[0]
-            py_minor = py_parts[1] if len(py_parts) > 1 else "0"
-            vars_dict["py_version"] = env_config.python
-            vars_dict["py_short"] = f"{py_major}{py_minor}"
-            vars_dict["py_minor"] = py_minor
-            vars_dict["py_tag"] = f"cp{py_major}{py_minor}"
-
-        for req in env_config.no_deps_requirements:
-            # Parse requirement (e.g., "cumesh" or "cumesh==0.0.1")
-            if "==" in req:
-                pkg_name, version = req.split("==", 1)
-            else:
-                pkg_name = req
-                version = None
-
-            pkg_lower = pkg_name.lower()
-            if pkg_lower in PACKAGE_REGISTRY:
-                config = PACKAGE_REGISTRY[pkg_lower]
-                template = config.get("wheel_template")
-                if template:
-                    # Use version from requirement or default
-                    v = version or config.get("default_version")
-                    if v:
-                        vars_dict["version"] = v
-
-                    # Resolve URL
-                    url = template
-                    for key, value in vars_dict.items():
-                        if value:
-                            url = url.replace(f"{{{key}}}", str(value))
-
-                    special_deps[pkg_name] = f'{{ url = "{url}" }}'
-                    log(f"  CUDA package {pkg_name}: resolved wheel URL")
+    # NOTE: CUDA packages (no_deps_requirements) are NOT added to pixi.toml.
+    # They are installed separately with pip --no-deps after pixi install
+    # to avoid transitive dependency conflicts. See pixi_install().
 
     # Add platform-specific requirements
     if sys.platform == "linux" and env_config.linux_requirements:
@@ -557,6 +595,36 @@ def pixi_install(
 
     log("pixi install completed successfully!")
 
+    # Phase 2: Install CUDA packages with pip --no-deps
+    # These are kept out of pixi.toml to avoid transitive dependency conflicts
+    # Skip on macOS - CUDA is not supported
+    if env_config.no_deps_requirements:
+        if sys.platform == "darwin":
+            log("Skipping CUDA packages (not supported on macOS)")
+        else:
+            log("Installing CUDA packages with --no-deps...")
+            python_path = get_pixi_python(node_dir)
+            if not python_path:
+                raise RuntimeError("Failed to find Python in pixi environment")
+
+            vars_dict = _build_cuda_vars(env_config)
+
+            for req in env_config.no_deps_requirements:
+                url = _resolve_cuda_wheel_url(req, vars_dict, log)
+                if url:
+                    log(f"  Installing {req} (--no-deps)...")
+                    result = subprocess.run(
+                        [str(python_path), "-m", "pip", "install", "--no-deps", url],
+                        capture_output=True,
+                        text=True,
+                    )
+                    if result.returncode != 0:
+                        log(f"  Failed to install {req}:")
+                        log(result.stderr)
+                        raise RuntimeError(f"Failed to install {req} with --no-deps: {result.stderr}")
+                else:
+                    log(f"  Warning: Could not resolve wheel URL for {req}, skipping")
+
     # Create _env_{name} link for compatibility with uv backend
     # This ensures code that expects _env_envname/bin/python works with pixi
     symlink_path = node_dir / f"_env_{env_config.name}"