comfy-env 0.0.64__tar.gz → 0.0.66__tar.gz

{comfy_env-0.0.64 → comfy_env-0.0.66}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.64
+Version: 0.0.66
 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
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: pyyaml>=6.0
+Requires-Dist: tomli-w>=1.0.0
 Requires-Dist: tomli>=2.0.0; python_version < '3.11'
 Requires-Dist: uv>=0.4.0
 Provides-Extra: dev

{comfy_env-0.0.64 → comfy_env-0.0.66}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfy-env"
-version = "0.0.64"
+version = "0.0.66"
 description = "Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation"
 readme = "README.md"
 license = {text = "MIT"}
@@ -20,6 +20,7 @@ classifiers = [
 ]
 dependencies = [
     "tomli>=2.0.0; python_version < '3.11'",  # TOML parsing (built-in tomllib for 3.11+)
+    "tomli-w>=1.0.0",  # TOML writing (no stdlib equivalent)
     "uv>=0.4.0",  # Fast Python package installer and venv creator
     "pyyaml>=6.0",  # YAML parsing for wheel_sources.yml
 ]
@@ -43,7 +44,7 @@ build-backend = "hatchling.build"
 packages = ["src/comfy_env"]
 
 [tool.hatch.build.targets.wheel.force-include]
-"src/comfy_env/wheel_sources.yml" = "comfy_env/wheel_sources.yml"
+"src/comfy_env/pixi/wheel_sources.yml" = "comfy_env/pixi/wheel_sources.yml"
 
 [tool.ruff]
 line-length = 100

comfy_env-0.0.66/src/comfy_env/__init__.py

@@ -0,0 +1,110 @@
+"""
+comfy-env: Environment management for ComfyUI custom nodes.
+
+All dependencies go through pixi for unified management.
+
+Main APIs:
+- install(): Install dependencies from comfy-env.toml
+- wrap_isolated_nodes(): Wrap nodes for subprocess isolation
+"""
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("comfy-env")
+except PackageNotFoundError:
+    __version__ = "0.0.0-dev"
+
+# Config types and parsing
+from .config import (
+    ComfyEnvConfig,
+    NodeReq,
+    load_config,
+    discover_config,
+    CONFIG_FILE_NAME,
+)
+
+# Pixi integration
+from .pixi import (
+    ensure_pixi,
+    get_pixi_path,
+    get_pixi_python,
+    pixi_run,
+    pixi_install,
+    CUDA_WHEELS_INDEX,
+    PACKAGE_REGISTRY,
+    detect_cuda_version,
+    detect_cuda_environment,
+    get_recommended_cuda_version,
+    GPUInfo,
+    CUDAEnvironment,
+)
+
+# Workers
+from .workers import (
+    Worker,
+    WorkerError,
+    MPWorker,
+    SubprocessWorker,
+)
+
+# Isolation
+from .isolation import wrap_isolated_nodes
+
+# Install API
+from .install import install, verify_installation
+
+# Prestartup helpers
+from .prestartup import setup_env
+
+# Errors
+from .errors import (
+    EnvManagerError,
+    ConfigError,
+    WheelNotFoundError,
+    DependencyError,
+    CUDANotFoundError,
+    InstallError,
+)
+
+__all__ = [
+    # Install API
+    "install",
+    "verify_installation",
+    # Prestartup
+    "setup_env",
+    # Isolation
+    "wrap_isolated_nodes",
+    # Config
+    "ComfyEnvConfig",
+    "NodeReq",
+    "load_config",
+    "discover_config",
+    "CONFIG_FILE_NAME",
+    # Pixi
+    "ensure_pixi",
+    "get_pixi_path",
+    "get_pixi_python",
+    "pixi_run",
+    "pixi_install",
+    "CUDA_WHEELS_INDEX",
+    "PACKAGE_REGISTRY",
+    # CUDA detection
+    "detect_cuda_version",
+    "detect_cuda_environment",
+    "get_recommended_cuda_version",
+    "GPUInfo",
+    "CUDAEnvironment",
+    # Workers
+    "Worker",
+    "WorkerError",
+    "MPWorker",
+    "SubprocessWorker",
+    # Errors
+    "EnvManagerError",
+    "ConfigError",
+    "WheelNotFoundError",
+    "DependencyError",
+    "CUDANotFoundError",
+    "InstallError",
+]

{comfy_env-0.0.64 → comfy_env-0.0.66}/src/comfy_env/cli.py

@@ -2,6 +2,8 @@
 CLI for comfy-env.
 
 Provides the `comfy-env` command with subcommands:
+- init: Create a default comfy-env.toml
+- generate: Generate pixi.toml from comfy-env.toml
 - install: Install dependencies from config
 - info: Show runtime environment information
 - resolve: Show resolved wheel URLs
@@ -9,7 +11,9 @@ Provides the `comfy-env` command with subcommands:
 - list-packages: Show all packages in the built-in registry
 
 Usage:
-    comfy-env install
+    comfy-env init ---> creates template comfy-env.toml
+    comfy-env generate nodes/cgal/comfy-env.toml ---> nodes/cgal/pixi.toml
+    comfy-env install ---> installs from comfy
     comfy-env install --dry-run
 
     comfy-env info
@@ -54,6 +58,23 @@ def main(args: Optional[List[str]] = None) -> int:
         help="Overwrite existing config file",
     )
 
+    # generate command
+    generate_parser = subparsers.add_parser(
+        "generate",
+        help="Generate pixi.toml from comfy-env.toml",
+        description="Parse comfy-env.toml and generate a pixi.toml in the same directory",
+    )
+    generate_parser.add_argument(
+        "config",
+        type=str,
+        help="Path to comfy-env.toml",
+    )
+    generate_parser.add_argument(
+        "--force", "-f",
+        action="store_true",
+        help="Overwrite existing pixi.toml",
+    )
+
     # install command
     install_parser = subparsers.add_parser(
         "install",
@@ -148,6 +169,8 @@ def main(args: Optional[List[str]] = None) -> int:
     try:
         if parsed.command == "init":
             return cmd_init(parsed)
+        elif parsed.command == "generate":
+            return cmd_generate(parsed)
         elif parsed.command == "install":
             return cmd_install(parsed)
         elif parsed.command == "info":
@@ -205,6 +228,53 @@ def cmd_init(args) -> int:
     return 0
 
 
+def cmd_generate(args) -> int:
+    """Handle generate command - create pixi.toml from comfy-env.toml."""
+    from .config.parser import load_config
+    from .pixi import create_pixi_toml
+
+    config_path = Path(args.config).resolve()
+
+    if not config_path.exists():
+        print(f"Config file not found: {config_path}", file=sys.stderr)
+        return 1
+
+    if config_path.name != "comfy-env.toml":
+        print(f"Warning: Expected comfy-env.toml, got {config_path.name}", file=sys.stderr)
+
+    node_dir = config_path.parent
+    pixi_path = node_dir / "pixi.toml"
+
+    if pixi_path.exists() and not args.force:
+        print(f"pixi.toml already exists: {pixi_path}", file=sys.stderr)
+        print("Use --force to overwrite", file=sys.stderr)
+        return 1
+
+    # Load the config
+    config = load_config(config_path)
+    if not config or not config.envs:
+        print(f"No environments found in {config_path}", file=sys.stderr)
+        return 1
+
+    # Use the first environment
+    env_name = next(iter(config.envs.keys()))
+    env_config = config.envs[env_name]
+
+    print(f"Generating pixi.toml from {config_path}")
+    print(f"  Environment: {env_name}")
+    print(f"  Python: {env_config.python}")
+
+    # Generate pixi.toml
+    result_path = create_pixi_toml(env_config, node_dir)
+
+    print(f"Created {result_path}")
+    print()
+    print("Next steps:")
+    print(f"  cd {node_dir}")
+    print("  pixi install")
+    return 0
+
+
 def cmd_install(args) -> int:
     """Handle install command."""
     from .install import install
@@ -228,7 +298,7 @@ def cmd_install(args) -> int:
 
 def cmd_info(args) -> int:
     """Handle info command."""
-    from .resolver import RuntimeEnv
+    from .pixi import RuntimeEnv
 
     env = RuntimeEnv.detect()
 
@@ -264,9 +334,10 @@ def cmd_info(args) -> int:
 
 def cmd_resolve(args) -> int:
     """Handle resolve command."""
-    from .resolver import RuntimeEnv, parse_wheel_requirement
-    from .registry import PACKAGE_REGISTRY, get_cuda_short2
-    from .env.config_file import discover_env_config, load_env_from_file
+    from .pixi import RuntimeEnv, parse_wheel_requirement
+    from .pixi import PACKAGE_REGISTRY
+    from .pixi.registry import get_cuda_short2
+    from .config.parser import discover_env_config, load_env_from_file
 
     env = RuntimeEnv.detect()
     packages = []
@@ -353,7 +424,7 @@ def _substitute_template(template: str, vars_dict: dict) -> str:
 def cmd_doctor(args) -> int:
     """Handle doctor command."""
     from .install import verify_installation
-    from .env.config_file import discover_env_config, load_env_from_file
+    from .config.parser import discover_env_config, load_env_from_file
 
     print("Running diagnostics...")
     print("=" * 40)
@@ -397,7 +468,7 @@ def cmd_doctor(args) -> int:
 
 def cmd_list_packages(args) -> int:
     """Handle list-packages command."""
-    from .registry import PACKAGE_REGISTRY
+    from .pixi import PACKAGE_REGISTRY
 
     if args.json:
         import json

comfy_env-0.0.66/src/comfy_env/config/__init__.py

@@ -0,0 +1,19 @@
+"""
+Config parsing for comfy-env.
+
+This module handles parsing comfy-env.toml files and provides
+typed configuration objects.
+"""
+
+from .types import ComfyEnvConfig, NodeReq
+from .parser import load_config, discover_config, CONFIG_FILE_NAME
+
+__all__ = [
+    # Types
+    "ComfyEnvConfig",
+    "NodeReq",
+    # Parser
+    "load_config",
+    "discover_config",
+    "CONFIG_FILE_NAME",
+]

comfy_env-0.0.66/src/comfy_env/config/parser.py

@@ -0,0 +1,151 @@
+"""Load configuration from comfy-env.toml.
+
+comfy-env.toml is a superset of pixi.toml. Custom sections we handle:
+- python = "3.11" - Python version for isolated envs
+- [cuda] packages = [...] - CUDA packages (triggers find-links + PyTorch detection)
+- [node_reqs] - Other ComfyUI nodes to clone
+
+Everything else passes through to pixi.toml directly.
+
+Example config:
+
+    python = "3.11"
+
+    [cuda]
+    packages = ["cumesh"]
+
+    [dependencies]
+    mesalib = "*"
+    cgal = "*"
+
+    [pypi-dependencies]
+    numpy = ">=1.21.0,<2"
+    trimesh = { version = ">=4.0.0", extras = ["easy"] }
+
+    [target.linux-64.pypi-dependencies]
+    embreex = "*"
+
+    [node_reqs]
+    SomeNode = "owner/repo"
+"""
+
+import copy
+import sys
+from pathlib import Path
+from typing import Optional, Dict, Any, List
+
+# Use built-in tomllib (Python 3.11+) or tomli fallback
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib
+    except ImportError:
+        tomllib = None  # type: ignore
+
+from .types import ComfyEnvConfig, NodeReq
+
+
+CONFIG_FILE_NAME = "comfy-env.toml"
+
+# Sections we handle specially (not passed through to pixi.toml)
+CUSTOM_SECTIONS = {"python", "cuda", "node_reqs"}
+
+
+def load_config(path: Path) -> ComfyEnvConfig:
+    """
+    Load configuration from a TOML file.
+
+    Args:
+        path: Path to comfy-env.toml
+
+    Returns:
+        ComfyEnvConfig instance
+
+    Raises:
+        FileNotFoundError: If config file doesn't exist
+        ImportError: If tomli not installed (Python < 3.11)
+    """
+    if tomllib is None:
+        raise ImportError(
+            "TOML parsing requires tomli for Python < 3.11. "
+            "Install with: pip install tomli"
+        )
+
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Config file not found: {path}")
+
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+
+    return _parse_config(data)
+
+
+def discover_config(node_dir: Path) -> Optional[ComfyEnvConfig]:
+    """
+    Find and load comfy-env.toml from a directory.
+
+    Args:
+        node_dir: Directory to search
+
+    Returns:
+        ComfyEnvConfig if found, None otherwise
+    """
+    if tomllib is None:
+        return None
+
+    config_path = Path(node_dir) / CONFIG_FILE_NAME
+    if config_path.exists():
+        return load_config(config_path)
+
+    return None
+
+
+def _parse_config(data: Dict[str, Any]) -> ComfyEnvConfig:
+    """Parse TOML data into ComfyEnvConfig."""
+    # Make a copy so we can pop our custom sections
+    data = copy.deepcopy(data)
+
+    # Extract python version (top-level key)
+    python_version = data.pop("python", None)
+    if python_version is not None:
+        python_version = str(python_version)
+
+    # Extract [cuda] section
+    cuda_data = data.pop("cuda", {})
+    cuda_packages = _ensure_list(cuda_data.get("packages", []))
+
+    # Extract [node_reqs] section
+    node_reqs_data = data.pop("node_reqs", {})
+    node_reqs = _parse_node_reqs(node_reqs_data)
+
+    # Everything else passes through to pixi.toml
+    pixi_passthrough = data
+
+    return ComfyEnvConfig(
+        python=python_version,
+        cuda_packages=cuda_packages,
+        node_reqs=node_reqs,
+        pixi_passthrough=pixi_passthrough,
+    )
+
+
+def _parse_node_reqs(data: Dict[str, Any]) -> List[NodeReq]:
+    """Parse [node_reqs] section."""
+    node_reqs = []
+    for name, value in data.items():
+        if isinstance(value, str):
+            node_reqs.append(NodeReq(name=name, repo=value))
+        elif isinstance(value, dict):
+            node_reqs.append(NodeReq(name=name, repo=value.get("repo", "")))
+    return node_reqs
+
+
+def _ensure_list(value) -> List:
+    """Ensure value is a list."""
+    if isinstance(value, list):
+        return value
+    if value:
+        return [value]
+    return []

comfy_env-0.0.66/src/comfy_env/config/types.py

@@ -0,0 +1,64 @@
+"""Configuration types for comfy-env."""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class NodeReq:
+    """A node dependency (another ComfyUI custom node)."""
+    name: str
+    repo: str  # GitHub repo, e.g., "owner/repo"
+
+
+@dataclass
+class ComfyEnvConfig:
+    """
+    Configuration from comfy-env.toml.
+
+    comfy-env.toml is a superset of pixi.toml. Custom sections we handle:
+    - python = "3.11" - Python version for isolated envs
+    - [cuda] packages = [...] - CUDA packages (triggers find-links + PyTorch detection)
+    - [node_reqs] - Other ComfyUI nodes to clone
+
+    Everything else passes through to pixi.toml directly:
+    - [dependencies] - conda packages
+    - [pypi-dependencies] - pip packages
+    - [target.linux-64.pypi-dependencies] - platform-specific deps
+    - Any other pixi.toml syntax
+
+    Example config:
+        python = "3.11"
+
+        [cuda]
+        packages = ["cumesh"]
+
+        [dependencies]
+        mesalib = "*"
+        cgal = "*"
+
+        [pypi-dependencies]
+        numpy = ">=1.21.0,<2"
+        trimesh = { version = ">=4.0.0", extras = ["easy"] }
+
+        [target.linux-64.pypi-dependencies]
+        embreex = "*"
+
+        [node_reqs]
+        SomeNode = "owner/repo"
+    """
+    # python = "3.11" - Python version (for isolated envs)
+    python: Optional[str] = None
+
+    # [cuda] - CUDA packages (installed via find-links index)
+    cuda_packages: List[str] = field(default_factory=list)
+
+    # [node_reqs] - other ComfyUI nodes to clone
+    node_reqs: List[NodeReq] = field(default_factory=list)
+
+    # Everything else from comfy-env.toml passes through to pixi.toml
+    pixi_passthrough: Dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def has_cuda(self) -> bool:
+        return bool(self.cuda_packages)

comfy_env-0.0.66/src/comfy_env/install.py

@@ -0,0 +1,171 @@
+"""
+Installation API for comfy-env.
+
+Example:
+    from comfy_env import install
+    install()  # Auto-discovers comfy-env.toml and installs
+"""
+
+import inspect
+from pathlib import Path
+from typing import Callable, List, Optional, Set, Union
+
+from .config.types import ComfyEnvConfig, NodeReq
+from .config.parser import load_config, discover_config
+
+
+def install(
+    config: Optional[Union[str, Path]] = None,
+    node_dir: Optional[Path] = None,
+    log_callback: Optional[Callable[[str], None]] = None,
+    dry_run: bool = False,
+) -> bool:
+    """
+    Install dependencies from comfy-env.toml.
+
+    Args:
+        config: Optional path to comfy-env.toml. Auto-discovered if not provided.
+        node_dir: Optional node directory. Auto-discovered from caller if not provided.
+        log_callback: Optional callback for logging. Defaults to print.
+        dry_run: If True, show what would be installed without installing.
+
+    Returns:
+        True if installation succeeded.
+    """
+    # Auto-discover caller's directory if not provided
+    if node_dir is None:
+        frame = inspect.stack()[1]
+        caller_file = frame.filename
+        node_dir = Path(caller_file).parent.resolve()
+
+    log = log_callback or print
+
+    # Load config
+    if config is not None:
+        config_path = Path(config)
+        if not config_path.is_absolute():
+            config_path = node_dir / config_path
+        cfg = load_config(config_path)
+    else:
+        cfg = discover_config(node_dir)
+
+    if cfg is None:
+        raise FileNotFoundError(
+            f"No comfy-env.toml found in {node_dir}. "
+            "Create comfy-env.toml to define dependencies."
+        )
+
+    # Install node dependencies first
+    if cfg.node_reqs:
+        _install_node_dependencies(cfg.node_reqs, node_dir, log, dry_run)
+
+    # Install everything via pixi
+    _install_via_pixi(cfg, node_dir, log, dry_run)
+
+    # Auto-discover and install isolated subdirectory environments
+    _install_isolated_subdirs(node_dir, log, dry_run)
+
+    log("\nInstallation complete!")
+    return True
+
+
+def _install_node_dependencies(
+    node_reqs: List[NodeReq],
+    node_dir: Path,
+    log: Callable[[str], None],
+    dry_run: bool,
+) -> None:
+    """Install node dependencies (other ComfyUI custom nodes)."""
+    from .nodes import install_node_deps
+
+    custom_nodes_dir = node_dir.parent
+    log(f"\nInstalling {len(node_reqs)} node dependencies...")
+
+    if dry_run:
+        for req in node_reqs:
+            node_path = custom_nodes_dir / req.name
+            status = "exists" if node_path.exists() else "would clone"
+            log(f"  {req.name}: {status}")
+        return
+
+    visited: Set[str] = {node_dir.name}
+    install_node_deps(node_reqs, custom_nodes_dir, log, visited)
+
+
+def _install_via_pixi(
+    cfg: ComfyEnvConfig,
+    node_dir: Path,
+    log: Callable[[str], None],
+    dry_run: bool,
+) -> None:
+    """Install all packages via pixi."""
+    from .pixi import pixi_install
+
+    # Count what we're installing
+    cuda_count = len(cfg.cuda_packages)
+
+    # Count from passthrough (pixi-native format)
+    deps = cfg.pixi_passthrough.get("dependencies", {})
+    pypi_deps = cfg.pixi_passthrough.get("pypi-dependencies", {})
+
+    if cuda_count == 0 and not deps and not pypi_deps:
+        log("No packages to install")
+        return
+
+    log(f"\nInstalling via pixi:")
+    if cuda_count:
+        log(f"  CUDA packages: {', '.join(cfg.cuda_packages)}")
+    if deps:
+        log(f"  Conda packages: {len(deps)}")
+    if pypi_deps:
+        log(f"  PyPI packages: {len(pypi_deps)}")
+
+    if dry_run:
+        log("\n(dry run - no changes made)")
+        return
+
+    pixi_install(cfg, node_dir, log)
+
+
+def _install_isolated_subdirs(
+    node_dir: Path,
+    log: Callable[[str], None],
+    dry_run: bool,
+) -> None:
+    """Find and install comfy-env.toml in subdirectories."""
+    from .pixi import pixi_install
+    from .config.parser import CONFIG_FILE_NAME
+
+    # Find all comfy-env.toml files in subdirectories (not root)
+    for config_file in node_dir.rglob(CONFIG_FILE_NAME):
+        if config_file.parent == node_dir:
+            continue  # Skip root (already installed)
+
+        sub_dir = config_file.parent
+        relative = sub_dir.relative_to(node_dir)
+
+        log(f"\n[isolated] Installing: {relative}")
+        sub_cfg = load_config(config_file)
+
+        if dry_run:
+            log(f"  (dry run)")
+            continue
+
+        pixi_install(sub_cfg, sub_dir, log, create_env_link=True)
+
+
+def verify_installation(
+    packages: List[str],
+    log: Callable[[str], None] = print,
+) -> bool:
+    """Verify that packages are importable."""
+    all_ok = True
+    for package in packages:
+        import_name = package.replace("-", "_").split("[")[0]
+        try:
+            __import__(import_name)
+            log(f"  {package}: OK")
+        except ImportError as e:
+            log(f"  {package}: FAILED ({e})")
+            all_ok = False
+    return all_ok