comfy-env 0.0.21__tar.gz → 0.0.22__tar.gz

{comfy_env-0.0.21 → comfy_env-0.0.22}/PKG-INFO

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

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

{comfy_env-0.0.21 → comfy_env-0.0.22}/src/comfy_env/__init__.py

@@ -1,6 +1,6 @@
 __version__ = "0.0.14"
 
-from .env.config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq
+from .env.config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, CondaConfig
 from .env.config_file import (
     load_env_from_file,
     discover_env_config,
@@ -33,6 +33,16 @@ from .decorator import isolated, shutdown_all_processes
 # New in-place installation API
 from .install import install, verify_installation
 from .resolver import RuntimeEnv, WheelResolver
+
+# Pixi integration (for conda packages)
+from .pixi import (
+    ensure_pixi,
+    get_pixi_path,
+    pixi_install,
+    create_pixi_toml,
+    get_pixi_python,
+    pixi_run,
+)
 from .errors import (
     EnvManagerError,
     ConfigError,
@@ -73,6 +83,13 @@ __all__ = [
     "verify_installation",
     "RuntimeEnv",
     "WheelResolver",
+    # Pixi integration (for conda packages)
+    "ensure_pixi",
+    "get_pixi_path",
+    "pixi_install",
+    "create_pixi_toml",
+    "get_pixi_python",
+    "pixi_run",
     # Errors
     "EnvManagerError",
     "ConfigError",
@@ -93,6 +110,7 @@ __all__ = [
     "EnvManagerConfig",
     "LocalConfig",
     "NodeReq",
+    "CondaConfig",
     "IsolatedEnvManager",
     # Config file loading
     "load_env_from_file",

{comfy_env-0.0.21 → comfy_env-0.0.22}/src/comfy_env/env/config.py

@@ -28,6 +28,17 @@ class LocalConfig:
     requirements: List[str] = field(default_factory=list)
 
 
+@dataclass
+class CondaConfig:
+    """Configuration for conda packages (installed via pixi).
+
+    When present, the environment uses pixi as the backend instead of uv.
+    Pixi manages both conda and pip packages in a unified environment.
+    """
+    channels: List[str] = field(default_factory=list)  # conda channels
+    packages: List[str] = field(default_factory=list)  # conda packages
+
+
 @dataclass
 class NodeReq:
     """A node dependency (another ComfyUI node pack)."""
@@ -139,6 +150,8 @@ class IsolatedEnv:
     # Worker configuration
     worker_package: Optional[str] = None  # e.g., "worker" -> worker/__main__.py
     worker_script: Optional[str] = None   # e.g., "worker.py" -> worker.py
+    # Conda configuration (uses pixi backend when present)
+    conda: Optional["CondaConfig"] = None
 
     def __post_init__(self):
         """Validate and normalize configuration."""
@@ -175,3 +188,8 @@ class IsolatedEnv:
         if self.env_dir is not None:
             return self.env_dir
         return base_dir / f"_env_{self.name}"
+
+    @property
+    def uses_conda(self) -> bool:
+        """Check if this environment uses conda packages (pixi backend)."""
+        return self.conda is not None and bool(self.conda.packages)

{comfy_env-0.0.21 → comfy_env-0.0.22}/src/comfy_env/env/config_file.py

@@ -63,7 +63,7 @@ else:
     except ImportError:
         tomllib = None  # type: ignore
 
-from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, SystemConfig, ToolConfig
+from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, SystemConfig, ToolConfig, CondaConfig
 from .cuda_gpu_detection import detect_cuda_version
 
 
@@ -515,15 +515,27 @@ def _parse_single_env(name: str, env_data: Dict[str, Any], base_dir: Path) -> Is
     if pytorch == "auto":
         pytorch = _get_default_pytorch_version(cuda)
 
-    # Parse [envname.cuda] - CUDA packages
+    # Parse [envname.conda] - conda packages (uses pixi backend)
+    conda_section = env_data.get("conda", {})
+    conda_config = None
+    if isinstance(conda_section, dict) and ("channels" in conda_section or "packages" in conda_section):
+        # This is a conda config with channels/packages
+        channels = conda_section.get("channels", [])
+        packages = conda_section.get("packages", [])
+        if packages:
+            conda_config = CondaConfig(channels=channels, packages=packages)
+
+    # Parse [envname.cuda] - CUDA packages (separate from conda)
     cuda_section = env_data.get("cuda", {})
     no_deps_requirements = []
     if isinstance(cuda_section, dict):
-        for pkg, ver in cuda_section.items():
-            if ver == "*" or ver == "":
-                no_deps_requirements.append(pkg)
-            else:
-                no_deps_requirements.append(f"{pkg}=={ver}")
+        # Skip if this looks like a conda section (has channels/packages keys)
+        if not ("channels" in cuda_section or "packages" in cuda_section):
+            for pkg, ver in cuda_section.items():
+                if ver == "*" or ver == "":
+                    no_deps_requirements.append(pkg)
+                else:
+                    no_deps_requirements.append(f"{pkg}=={ver}")
 
     # Parse [envname.packages] - regular packages
     packages_section = env_data.get("packages", {})
@@ -567,6 +579,7 @@ def _parse_single_env(name: str, env_data: Dict[str, Any], base_dir: Path) -> Is
         windows_requirements=windows_reqs,
         linux_requirements=linux_reqs,
         darwin_requirements=darwin_reqs,
+        conda=conda_config,
     )
 
 

{comfy_env-0.0.21 → comfy_env-0.0.22}/src/comfy_env/install.py

@@ -25,10 +25,11 @@ from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Union
 
 from .env.config import IsolatedEnv, SystemConfig
-from .env.config_file import discover_env_config, load_env_from_file, load_config, discover_config
+from .env.config_file import load_config, discover_config
 from .env.manager import IsolatedEnvManager
 from .errors import CUDANotFoundError, DependencyError, InstallError, WheelNotFoundError
-from .registry import PACKAGE_REGISTRY, get_cuda_short2, is_registered
+from .pixi import pixi_install
+from .registry import PACKAGE_REGISTRY, get_cuda_short2
 from .resolver import RuntimeEnv, WheelResolver, parse_wheel_requirement
 
 
@@ -198,6 +199,11 @@ def install(
     if env_config:
         log(f"Found configuration: {env_config.name}")
 
+    # Check if environment uses conda packages (pixi backend)
+    if env_config and env_config.uses_conda:
+        log(f"Environment uses conda packages - using pixi backend")
+        return pixi_install(env_config, node_dir, log, dry_run)
+
     if mode == "isolated" and env_config:
         return _install_isolated(env_config, node_dir, log, dry_run)
     elif env_config:
@@ -206,20 +212,6 @@ def install(
         return True
 
 
-def _load_config(
-    config: Optional[Union[str, Path]],
-    node_dir: Path,
-) -> Optional[IsolatedEnv]:
-    """Load configuration from file or auto-discover."""
-    if config is not None:
-        config_path = Path(config)
-        if not config_path.is_absolute():
-            config_path = node_dir / config_path
-        return load_env_from_file(config_path, node_dir)
-
-    return discover_env_config(node_dir)
-
-
 def _load_full_config(config: Optional[Union[str, Path]], node_dir: Path):
     """Load full EnvManagerConfig (includes tools)."""
     from .env.config import EnvManagerConfig

comfy_env-0.0.22/src/comfy_env/pixi.py

@@ -0,0 +1,397 @@
+"""
+Pixi integration for comfy-env.
+
+Pixi is a fast package manager that supports both conda and pip packages.
+When an environment has conda packages defined, we use pixi as the backend
+instead of uv.
+
+See: https://pixi.sh/
+"""
+
+import os
+import platform
+import shutil
+import stat
+import subprocess
+import sys
+from pathlib import Path
+from typing import Callable, List, Optional
+
+from .env.config import IsolatedEnv, CondaConfig
+
+
+# Pixi download URLs by platform
+PIXI_URLS = {
+    ("Linux", "x86_64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-x86_64-unknown-linux-musl",
+    ("Linux", "aarch64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-aarch64-unknown-linux-musl",
+    ("Darwin", "x86_64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-x86_64-apple-darwin",
+    ("Darwin", "arm64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-aarch64-apple-darwin",
+    ("Windows", "AMD64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-x86_64-pc-windows-msvc.exe",
+}
+
+
+def get_pixi_path() -> Optional[Path]:
+    """
+    Find the pixi executable.
+
+    Checks:
+    1. System PATH
+    2. ~/.pixi/bin/pixi
+    3. ~/.local/bin/pixi
+
+    Returns:
+        Path to pixi executable, or None if not found.
+    """
+    # Check system PATH
+    pixi_cmd = shutil.which("pixi")
+    if pixi_cmd:
+        return Path(pixi_cmd)
+
+    # Check common install locations
+    home = Path.home()
+    candidates = [
+        home / ".pixi" / "bin" / "pixi",
+        home / ".local" / "bin" / "pixi",
+    ]
+
+    # Add .exe on Windows
+    if sys.platform == "win32":
+        candidates = [p.with_suffix(".exe") for p in candidates]
+
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+
+    return None
+
+
+def ensure_pixi(
+    install_dir: Optional[Path] = None,
+    log: Callable[[str], None] = print,
+) -> Path:
+    """
+    Ensure pixi is installed, downloading if necessary.
+
+    Args:
+        install_dir: Directory to install pixi to. Defaults to ~/.local/bin/
+        log: Logging callback.
+
+    Returns:
+        Path to pixi executable.
+
+    Raises:
+        RuntimeError: If pixi cannot be installed.
+    """
+    # Check if already installed
+    existing = get_pixi_path()
+    if existing:
+        log(f"Found pixi at: {existing}")
+        return existing
+
+    log("Pixi not found, downloading...")
+
+    # Determine install location
+    if install_dir is None:
+        install_dir = Path.home() / ".local" / "bin"
+    install_dir.mkdir(parents=True, exist_ok=True)
+
+    # Determine download URL
+    system = platform.system()
+    machine = platform.machine()
+
+    # Normalize machine name
+    if machine in ("x86_64", "AMD64"):
+        machine = "x86_64" if system != "Windows" else "AMD64"
+    elif machine in ("arm64", "aarch64"):
+        machine = "arm64" if system == "Darwin" else "aarch64"
+
+    url_key = (system, machine)
+    if url_key not in PIXI_URLS:
+        raise RuntimeError(
+            f"No pixi download available for {system}/{machine}. "
+            f"Available: {list(PIXI_URLS.keys())}"
+        )
+
+    url = PIXI_URLS[url_key]
+    pixi_path = install_dir / ("pixi.exe" if system == "Windows" else "pixi")
+
+    log(f"Downloading pixi from: {url}")
+
+    # Download using curl or urllib
+    try:
+        import urllib.request
+        urllib.request.urlretrieve(url, pixi_path)
+    except Exception as e:
+        # Try curl as fallback
+        result = subprocess.run(
+            ["curl", "-fsSL", "-o", str(pixi_path), url],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            raise RuntimeError(f"Failed to download pixi: {result.stderr}") from e
+
+    # Make executable on Unix
+    if system != "Windows":
+        pixi_path.chmod(pixi_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+    # Verify installation
+    result = subprocess.run([str(pixi_path), "--version"], capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"Pixi installation failed: {result.stderr}")
+
+    log(f"Installed pixi {result.stdout.strip()} to: {pixi_path}")
+    return pixi_path
+
+
+def create_pixi_toml(
+    env_config: IsolatedEnv,
+    node_dir: Path,
+    log: Callable[[str], None] = print,
+) -> Path:
+    """
+    Generate a pixi.toml file from the environment configuration.
+
+    The generated pixi.toml includes:
+    - Project metadata
+    - Conda channels
+    - Conda dependencies
+    - PyPI dependencies (from requirements + no_deps_requirements)
+
+    Args:
+        env_config: The isolated environment configuration.
+        node_dir: Directory to write pixi.toml to.
+        log: Logging callback.
+
+    Returns:
+        Path to the generated pixi.toml file.
+    """
+    if not env_config.conda:
+        raise ValueError("Environment has no conda configuration")
+
+    conda = env_config.conda
+    pixi_toml_path = node_dir / "pixi.toml"
+
+    # Build pixi.toml content
+    lines = []
+
+    # Project section
+    lines.append("[project]")
+    lines.append(f'name = "{env_config.name}"')
+    lines.append('version = "0.1.0"')
+
+    # Channels
+    channels = conda.channels or ["conda-forge"]
+    channels_str = ", ".join(f'"{ch}"' for ch in channels)
+    lines.append(f"channels = [{channels_str}]")
+
+    # Platforms
+    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"]')
+    elif sys.platform == "win32":
+        lines.append('platforms = ["win-64"]')
+
+    lines.append("")
+
+    # Dependencies section (conda packages)
+    lines.append("[dependencies]")
+    lines.append(f'python = "{env_config.python}.*"')
+
+    for pkg in conda.packages:
+        # Parse package spec (name=version or name>=version or just name)
+        if "=" in pkg and not pkg.startswith("="):
+            # Has version spec
+            if ">=" in pkg:
+                name, version = pkg.split(">=", 1)
+                lines.append(f'{name} = ">={version}"')
+            elif "==" in pkg:
+                name, version = pkg.split("==", 1)
+                lines.append(f'{name} = "=={version}"')
+            else:
+                # Single = means exact version in conda
+                name, version = pkg.split("=", 1)
+                lines.append(f'{name} = "=={version}"')
+        else:
+            # No version, use any
+            lines.append(f'{pkg} = "*"')
+
+    lines.append("")
+
+    # PyPI dependencies section
+    pypi_deps = []
+
+    # Add regular requirements
+    if env_config.requirements:
+        pypi_deps.extend(env_config.requirements)
+
+    # Add CUDA packages (no_deps_requirements)
+    if env_config.no_deps_requirements:
+        pypi_deps.extend(env_config.no_deps_requirements)
+
+    # Add platform-specific requirements
+    if sys.platform == "linux" and env_config.linux_requirements:
+        pypi_deps.extend(env_config.linux_requirements)
+    elif sys.platform == "darwin" and env_config.darwin_requirements:
+        pypi_deps.extend(env_config.darwin_requirements)
+    elif sys.platform == "win32" and env_config.windows_requirements:
+        pypi_deps.extend(env_config.windows_requirements)
+
+    if pypi_deps:
+        lines.append("[pypi-dependencies]")
+        for dep in pypi_deps:
+            # Parse pip requirement format to pixi format
+            dep_clean = dep.strip()
+            if ">=" in dep_clean:
+                name, version = dep_clean.split(">=", 1)
+                # Handle complex version specs like ">=1.0,<2.0"
+                name = name.strip()
+                version = version.strip()
+                lines.append(f'{name} = ">={version}"')
+            elif "==" in dep_clean:
+                name, version = dep_clean.split("==", 1)
+                lines.append(f'{name.strip()} = "=={version.strip()}"')
+            elif ">" in dep_clean:
+                name, version = dep_clean.split(">", 1)
+                lines.append(f'{name.strip()} = ">{version.strip()}"')
+            elif "<" in dep_clean:
+                name, version = dep_clean.split("<", 1)
+                lines.append(f'{name.strip()} = "<{version.strip()}"')
+            else:
+                # No version spec
+                lines.append(f'{dep_clean} = "*"')
+
+    content = "\n".join(lines) + "\n"
+
+    # Write the file
+    pixi_toml_path.write_text(content)
+    log(f"Generated pixi.toml at: {pixi_toml_path}")
+
+    return pixi_toml_path
+
+
+def pixi_install(
+    env_config: IsolatedEnv,
+    node_dir: Path,
+    log: Callable[[str], None] = print,
+    dry_run: bool = False,
+) -> bool:
+    """
+    Install conda and pip packages using pixi.
+
+    This is the main entry point for pixi-based installation. It:
+    1. Ensures pixi is installed
+    2. Generates pixi.toml from the config
+    3. Runs `pixi install` to install all dependencies
+
+    Args:
+        env_config: The isolated environment configuration.
+        node_dir: Directory containing the node (where pixi.toml will be created).
+        log: Logging callback.
+        dry_run: If True, only show what would be done.
+
+    Returns:
+        True if installation succeeded.
+
+    Raises:
+        RuntimeError: If installation fails.
+    """
+    log(f"Installing {env_config.name} with pixi backend...")
+
+    if dry_run:
+        log("Dry run - would:")
+        log(f"  - Ensure pixi is installed")
+        log(f"  - Generate pixi.toml in {node_dir}")
+        if env_config.conda:
+            log(f"  - Install {len(env_config.conda.packages)} conda packages")
+        if env_config.requirements:
+            log(f"  - Install {len(env_config.requirements)} pip packages")
+        return True
+
+    # Ensure pixi is installed
+    pixi_path = ensure_pixi(log=log)
+
+    # Generate pixi.toml
+    pixi_toml = create_pixi_toml(env_config, node_dir, log)
+
+    # Run pixi install
+    log("Running pixi install...")
+    result = subprocess.run(
+        [str(pixi_path), "install"],
+        cwd=node_dir,
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        log(f"pixi install failed:")
+        log(result.stderr)
+        raise RuntimeError(f"pixi install failed: {result.stderr}")
+
+    if result.stdout:
+        # Log output, but filter for key info
+        for line in result.stdout.strip().split("\n"):
+            if line.strip():
+                log(f"  {line}")
+
+    log("pixi install completed successfully!")
+    return True
+
+
+def get_pixi_python(node_dir: Path) -> Optional[Path]:
+    """
+    Get the path to the Python interpreter in the pixi environment.
+
+    Args:
+        node_dir: Directory containing pixi.toml.
+
+    Returns:
+        Path to Python executable in the pixi env, or None if not found.
+    """
+    # Pixi creates .pixi/envs/default/ in the project directory
+    env_dir = node_dir / ".pixi" / "envs" / "default"
+
+    if sys.platform == "win32":
+        python_path = env_dir / "python.exe"
+    else:
+        python_path = env_dir / "bin" / "python"
+
+    if python_path.exists():
+        return python_path
+
+    return None
+
+
+def pixi_run(
+    command: List[str],
+    node_dir: Path,
+    log: Callable[[str], None] = print,
+) -> subprocess.CompletedProcess:
+    """
+    Run a command in the pixi environment.
+
+    Args:
+        command: Command and arguments to run.
+        node_dir: Directory containing pixi.toml.
+        log: Logging callback.
+
+    Returns:
+        CompletedProcess result.
+    """
+    pixi_path = get_pixi_path()
+    if not pixi_path:
+        raise RuntimeError("Pixi not found")
+
+    full_cmd = [str(pixi_path), "run"] + command
+    log(f"Running: pixi run {' '.join(command)}")
+
+    return subprocess.run(
+        full_cmd,
+        cwd=node_dir,
+        capture_output=True,
+        text=True,
+    )