comfy-env 0.0.64__py3-none-any.whl → 0.0.66__py3-none-any.whl

comfy_env/__init__.py

@@ -1,55 +1,63 @@
+"""
+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"  # Fallback for editable installs
+    __version__ = "0.0.0-dev"
 
-from .env.config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, CondaConfig
-from .env.config_file import (
-    load_env_from_file,
-    discover_env_config,
+# Config types and parsing
+from .config import (
+    ComfyEnvConfig,
+    NodeReq,
     load_config,
     discover_config,
-    CONFIG_FILE_NAMES,
+    CONFIG_FILE_NAME,
 )
-from .env.manager import IsolatedEnvManager
-from .env.cuda_gpu_detection import (
-    GPUInfo,
-    CUDAEnvironment,
-    detect_cuda_environment,
-    detect_cuda_version,
-    detect_gpu_info,
-    detect_gpus,
-    get_gpu_summary,
-    get_recommended_cuda_version,
-)
-from .env.security import (
-    normalize_env_name,
-    validate_dependency,
-    validate_dependencies,
-    validate_path_within_root,
-    validate_wheel_url,
-)
-from .ipc.bridge import WorkerBridge
-from .ipc.worker import BaseWorker, register
-from .decorator import isolated, shutdown_all_processes
-from .isolation import enable_isolation
-from .stub_imports import setup_isolated_imports, cleanup_stubs
-
-# New in-place installation API
-from .install import install, verify_installation
-from .resolver import RuntimeEnv
 
-# Pixi integration (for conda packages)
+# Pixi integration
 from .pixi import (
     ensure_pixi,
     get_pixi_path,
-    pixi_install,
-    create_pixi_toml,
     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,
@@ -59,43 +67,39 @@ from .errors import (
     InstallError,
 )
 
-# New workers module (recommended API)
-from .workers import (
-    Worker,
-    TorchMPWorker,
-    VenvWorker,
-    WorkerPool,
-    get_worker,
-    register_worker,
-    shutdown_workers,
-)
-
-# TorchBridge is optional (requires PyTorch)
-try:
-    from .ipc.torch_bridge import TorchBridge, TorchWorker
-    _TORCH_AVAILABLE = True
-except ImportError:
-    _TORCH_AVAILABLE = False
-
-# PersistentVenvWorker requires the ipc.transport module
-try:
-    from .workers.venv import PersistentVenvWorker
-    _PERSISTENT_AVAILABLE = True
-except ImportError:
-    _PERSISTENT_AVAILABLE = False
-
 __all__ = [
-    # NEW: In-place installation API
+    # Install API
     "install",
     "verify_installation",
-    "RuntimeEnv",
-    # Pixi integration (for conda packages)
+    # Prestartup
+    "setup_env",
+    # Isolation
+    "wrap_isolated_nodes",
+    # Config
+    "ComfyEnvConfig",
+    "NodeReq",
+    "load_config",
+    "discover_config",
+    "CONFIG_FILE_NAME",
+    # Pixi
     "ensure_pixi",
     "get_pixi_path",
-    "pixi_install",
-    "create_pixi_toml",
     "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",
@@ -103,60 +107,4 @@ __all__ = [
     "DependencyError",
     "CUDANotFoundError",
     "InstallError",
-    # Workers API (recommended for isolation)
-    "Worker",
-    "TorchMPWorker",
-    "VenvWorker",
-    "WorkerPool",
-    "get_worker",
-    "register_worker",
-    "shutdown_workers",
-    # Environment & Config
-    "IsolatedEnv",
-    "EnvManagerConfig",
-    "LocalConfig",
-    "NodeReq",
-    "CondaConfig",
-    "IsolatedEnvManager",
-    # Config file loading
-    "load_env_from_file",
-    "discover_env_config",
-    "load_config",
-    "discover_config",
-    "CONFIG_FILE_NAMES",
-    # Detection
-    "GPUInfo",
-    "CUDAEnvironment",
-    "detect_cuda_environment",
-    "detect_cuda_version",
-    "detect_gpu_info",
-    "detect_gpus",
-    "get_gpu_summary",
-    "get_recommended_cuda_version",
-    # Security validation
-    "normalize_env_name",
-    "validate_dependency",
-    "validate_dependencies",
-    "validate_path_within_root",
-    "validate_wheel_url",
-    # Legacy IPC (subprocess-based)
-    "WorkerBridge",
-    "BaseWorker",
-    "register",
-    # Legacy Decorator API
-    "isolated",
-    "shutdown_all_processes",
-    # New: Enable isolation for entire node pack
-    "enable_isolation",
-    # Import stubbing for isolated packages
-    "setup_isolated_imports",
-    "cleanup_stubs",
 ]
-
-# Add torch-based IPC if available
-if _TORCH_AVAILABLE:
-    __all__ += ["TorchBridge", "TorchWorker"]
-
-# Add PersistentVenvWorker if available
-if _PERSISTENT_AVAILABLE:
-    __all__ += ["PersistentVenvWorker"]

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/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/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/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)