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

comfy_env-0.0.22/.github/workflows/publish.yml

@@ -0,0 +1,67 @@
+name: Bump Version & Publish
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  bump-and-publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Get current version
+        id: get_version
+        run: |
+          current=$(grep '^version = ' pyproject.toml | sed 's/version = "\(.*\)"/\1/' | tr -d '\r')
+          echo "current=$current" >> $GITHUB_OUTPUT
+
+      - name: Bump patch version
+        id: bump_version
+        run: |
+          current="${{ steps.get_version.outputs.current }}"
+          IFS='.' read -r major minor patch <<< "$current"
+          new_patch=$((patch + 1))
+          new_version="${major}.${minor}.${new_patch}"
+          sed -i "s/^version = \".*\"/version = \"${new_version}\"/" pyproject.toml
+          echo "new_version=$new_version" >> $GITHUB_OUTPUT
+          echo "Bumped version: $current -> $new_version"
+
+      - name: Commit version bump
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add pyproject.toml
+          git commit -m "Bump version to ${{ steps.bump_version.outputs.new_version }} [skip ci]"
+          git tag "v${{ steps.bump_version.outputs.new_version }}"
+          git push origin main --tags
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: v${{ steps.bump_version.outputs.new_version }}
+          name: v${{ steps.bump_version.outputs.new_version }}
+          generate_release_notes: true
+          files: dist/*
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.19
+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
@@ -126,7 +126,7 @@ comfy-env resolve nvdiffrast==0.4.0
 comfy-env doctor
 ```
 
-## Configuration
+## Configurations
 
 ### comfy-env.toml
 

{comfy_env-0.0.19 → comfy_env-0.0.22}/README.md

@@ -98,7 +98,7 @@ comfy-env resolve nvdiffrast==0.4.0
 comfy-env doctor
 ```
 
-## Configuration
+## Configurations
 
 ### comfy-env.toml
 

{comfy_env-0.0.19 → comfy_env-0.0.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfy-env"
-version = "0.0.19"
+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.19 → 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.19 → comfy_env-0.0.22}/src/comfy_env/decorator.py

@@ -113,6 +113,31 @@ def _clone_tensor_if_needed(obj: Any, smart_clone: bool = True) -> Any:
     return obj
 
 
+def _find_node_package_dir(source_file: Path) -> Path:
+    """
+    Find the node package root directory by searching for comfy-env.toml.
+
+    Walks up from the source file's directory until it finds a config file,
+    or falls back to heuristics if not found.
+    """
+    from .env.config_file import CONFIG_FILE_NAMES
+
+    current = source_file.parent
+
+    # Walk up the directory tree looking for config file
+    while current != current.parent:  # Stop at filesystem root
+        for config_name in CONFIG_FILE_NAMES:
+            if (current / config_name).exists():
+                return current
+        current = current.parent
+
+    # Fallback: use old heuristic if no config found
+    node_dir = source_file.parent
+    if node_dir.name == "nodes":
+        return node_dir.parent
+    return node_dir
+
+
 # ---------------------------------------------------------------------------
 # Worker Management
 # ---------------------------------------------------------------------------
@@ -262,10 +287,7 @@ def isolated(
         # Get source file info for sys.path setup
         source_file = Path(inspect.getfile(cls))
         node_dir = source_file.parent
-        if node_dir.name == "nodes":
-            node_package_dir = node_dir.parent
-        else:
-            node_package_dir = node_dir
+        node_package_dir = _find_node_package_dir(source_file)
 
         # Build sys.path for worker
         sys_path_additions = [str(node_dir)]
@@ -367,13 +389,10 @@ def isolated(
                     call_kwargs = {k: _clone_tensor_if_needed(v) for k, v in call_kwargs.items()}
 
                 # Get module name for import in worker
+                # Note: ComfyUI uses full filesystem paths as module names for custom nodes.
+                # The worker's _execute_method_call handles this by using file-based imports.
                 module_name = cls.__module__
 
-                # Handle ComfyUI's dynamic import which can set __module__ to a path
-                if module_name.startswith('/') or module_name.startswith('\\'):
-                    # Module name is a filesystem path - use the source file stem instead
-                    module_name = source_file.stem
-
                 # Call worker using appropriate method
                 if worker_config.python is None:
                     # TorchMPWorker - use call_method protocol (avoids pickle issues)

{comfy_env-0.0.19 → 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.19 → 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.19 → 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,
+    )

{comfy_env-0.0.19 → comfy_env-0.0.22}/src/comfy_env/workers/torch_mp.py

@@ -106,6 +106,190 @@ def _worker_loop(queue_in, queue_out, sys_path_additions=None):
             break
 
 
+class PathBasedModuleFinder:
+    """
+    Meta path finder that handles ComfyUI's path-based module names.
+
+    ComfyUI uses full filesystem paths as module names for custom nodes.
+    This finder intercepts imports of such modules and loads them from disk.
+    """
+
+    def find_spec(self, fullname, path, target=None):
+        import importlib.util
+        import os
+
+        # Only handle path-based module names (starting with /)
+        if not fullname.startswith('/'):
+            return None
+
+        # Parse the module name to find base path and submodule parts
+        parts = fullname.split('.')
+        base_path = parts[0]
+        submodule_parts = parts[1:] if len(parts) > 1 else []
+
+        # Walk through parts to find where path ends and module begins
+        for i, part in enumerate(submodule_parts):
+            test_path = os.path.join(base_path, part)
+            if os.path.exists(test_path):
+                base_path = test_path
+            else:
+                # Remaining parts are module names
+                submodule_parts = submodule_parts[i:]
+                break
+        else:
+            # All parts were path components
+            submodule_parts = []
+
+        # Determine the file to load
+        if submodule_parts:
+            # We're importing a submodule
+            current_path = base_path
+            for part in submodule_parts[:-1]:
+                current_path = os.path.join(current_path, part)
+
+            submod = submodule_parts[-1]
+            submod_file = os.path.join(current_path, submod + '.py')
+            submod_pkg = os.path.join(current_path, submod, '__init__.py')
+
+            if os.path.exists(submod_file):
+                return importlib.util.spec_from_file_location(fullname, submod_file)
+            elif os.path.exists(submod_pkg):
+                return importlib.util.spec_from_file_location(
+                    fullname, submod_pkg,
+                    submodule_search_locations=[os.path.join(current_path, submod)]
+                )
+        else:
+            # Top-level path-based module
+            if os.path.isdir(base_path):
+                init_path = os.path.join(base_path, "__init__.py")
+                if os.path.exists(init_path):
+                    return importlib.util.spec_from_file_location(
+                        fullname, init_path,
+                        submodule_search_locations=[base_path]
+                    )
+            elif os.path.isfile(base_path):
+                return importlib.util.spec_from_file_location(fullname, base_path)
+
+        return None
+
+
+# Global flag to track if we've installed the finder
+_path_finder_installed = False
+
+
+def _ensure_path_finder_installed():
+    """Install the PathBasedModuleFinder if not already installed."""
+    import sys
+    global _path_finder_installed
+    if not _path_finder_installed:
+        sys.meta_path.insert(0, PathBasedModuleFinder())
+        _path_finder_installed = True
+        logger.debug("[comfy_env] Installed PathBasedModuleFinder for path-based module names")
+
+
+def _load_path_based_module(module_name: str):
+    """
+    Load a module that has a filesystem path as its name.
+
+    ComfyUI uses full filesystem paths as module names for custom nodes.
+    This function handles that case by using file-based imports.
+    """
+    import importlib.util
+    import os
+    import sys
+
+    # Check if it's already in sys.modules
+    if module_name in sys.modules:
+        return sys.modules[module_name]
+
+    # Check if module_name contains submodule parts (e.g., "/path/to/pkg.submod.subsubmod")
+    # In this case, we need to load the parent packages first
+    if '.' in module_name:
+        parts = module_name.split('.')
+        # Find where the path ends and module parts begin
+        # The path part won't exist as a directory when combined with module parts
+        base_path = parts[0]
+        submodule_parts = []
+
+        for i, part in enumerate(parts[1:], 1):
+            test_path = os.path.join(base_path, part)
+            if os.path.exists(test_path):
+                base_path = test_path
+            else:
+                # This and remaining parts are module names, not path components
+                submodule_parts = parts[i:]
+                break
+
+        if submodule_parts:
+            # Load parent package first
+            parent_module = _load_path_based_module(base_path)
+
+            # Now load submodules
+            current_module = parent_module
+            current_name = base_path
+            for submod in submodule_parts:
+                current_name = f"{current_name}.{submod}"
+                if current_name in sys.modules:
+                    current_module = sys.modules[current_name]
+                else:
+                    # Try to import as attribute or load from file
+                    if hasattr(current_module, submod):
+                        current_module = getattr(current_module, submod)
+                    else:
+                        # Try to load the submodule file
+                        if hasattr(current_module, '__path__'):
+                            for parent_path in current_module.__path__:
+                                submod_file = os.path.join(parent_path, submod + '.py')
+                                submod_pkg = os.path.join(parent_path, submod, '__init__.py')
+                                if os.path.exists(submod_file):
+                                    spec = importlib.util.spec_from_file_location(current_name, submod_file)
+                                    current_module = importlib.util.module_from_spec(spec)
+                                    current_module.__package__ = f"{base_path}.{'.'.join(submodule_parts[:-1])}" if len(submodule_parts) > 1 else base_path
+                                    sys.modules[current_name] = current_module
+                                    spec.loader.exec_module(current_module)
+                                    break
+                                elif os.path.exists(submod_pkg):
+                                    spec = importlib.util.spec_from_file_location(current_name, submod_pkg,
+                                        submodule_search_locations=[os.path.dirname(submod_pkg)])
+                                    current_module = importlib.util.module_from_spec(spec)
+                                    sys.modules[current_name] = current_module
+                                    spec.loader.exec_module(current_module)
+                                    break
+                        else:
+                            raise ModuleNotFoundError(f"Cannot find submodule {submod} in {current_name}")
+            return current_module
+
+    # Simple path-based module (no submodule parts)
+    if os.path.isdir(module_name):
+        init_path = os.path.join(module_name, "__init__.py")
+        submodule_search_locations = [module_name]
+    else:
+        init_path = module_name
+        submodule_search_locations = None
+
+    if not os.path.exists(init_path):
+        raise ModuleNotFoundError(f"Cannot find module at path: {module_name}")
+
+    spec = importlib.util.spec_from_file_location(
+        module_name,
+        init_path,
+        submodule_search_locations=submodule_search_locations
+    )
+    module = importlib.util.module_from_spec(spec)
+
+    # Set up package attributes for relative imports
+    if os.path.isdir(module_name):
+        module.__path__ = [module_name]
+        module.__package__ = module_name
+    else:
+        module.__package__ = module_name.rsplit('.', 1)[0] if '.' in module_name else ''
+
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+
+    return module
+
+
 def _execute_method_call(module_name: str, class_name: str, method_name: str,
                          self_state: dict, kwargs: dict) -> Any:
     """
@@ -114,9 +298,28 @@ def _execute_method_call(module_name: str, class_name: str, method_name: str,
     This function imports the class fresh and calls the original (un-decorated) method.
     """
     import importlib
+    import os
+    import sys
 
     # Import the module
-    module = importlib.import_module(module_name)
+    logger.debug(f"Attempting to import module_name={module_name}")
+
+    # Check if module_name is a filesystem path (ComfyUI uses paths as module names)
+    # This happens because ComfyUI's load_custom_node uses the full path as sys_module_name
+    if module_name.startswith('/') or (os.sep in module_name and not module_name.startswith('.')):
+        # Check if the base path exists to confirm it's a path-based module
+        base_path = module_name.split('.')[0] if '.' in module_name else module_name
+        if os.path.exists(base_path):
+            logger.debug(f"Detected path-based module name, using file-based import")
+            # Install the meta path finder to handle relative imports within the package
+            _ensure_path_finder_installed()
+            module = _load_path_based_module(module_name)
+        else:
+            # Doesn't look like a valid path, try standard import
+            module = importlib.import_module(module_name)
+    else:
+        # Standard module name - use importlib.import_module
+        module = importlib.import_module(module_name)
     cls = getattr(module, class_name)
 
     # Create instance with proper __slots__ handling

comfy_env-0.0.19/.github/workflows/publish.yml

@@ -1,28 +0,0 @@
-name: Publish to PyPI
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    environment: pypi
-    permissions:
-      id-token: write  # Required for trusted publishing
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Install build tools
-        run: pip install build
-
-      - name: Build package
-        run: python -m build
-
-      - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1