comfy-env 0.0.65__py3-none-any.whl → 0.0.67__py3-none-any.whl

comfy_env/__init__.py

@@ -1,55 +1,62 @@
+"""
+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,
+    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 +66,38 @@ 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",
+    # CUDA detection
+    "detect_cuda_version",
+    "detect_cuda_environment",
+    "get_recommended_cuda_version",
+    "GPUInfo",
+    "CUDAEnvironment",
+    # Workers
+    "Worker",
+    "WorkerError",
+    "MPWorker",
+    "SubprocessWorker",
     # Errors
     "EnvManagerError",
     "ConfigError",
@@ -103,60 +105,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,24 +2,21 @@
 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
 - doctor: Verify installation
-- 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
 
-    comfy-env resolve nvdiffrast==0.4.0
-    comfy-env resolve --all
-
     comfy-env doctor
-
-    comfy-env list-packages
 """
 
 import argparse
@@ -54,6 +51,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",
@@ -88,28 +102,6 @@ def main(args: Optional[List[str]] = None) -> int:
         help="Output as JSON",
     )
 
-    # resolve command
-    resolve_parser = subparsers.add_parser(
-        "resolve",
-        help="Resolve wheel URLs for packages",
-        description="Show resolved wheel URLs without installing",
-    )
-    resolve_parser.add_argument(
-        "packages",
-        nargs="*",
-        help="Package specs (e.g., nvdiffrast==0.4.0)",
-    )
-    resolve_parser.add_argument(
-        "--all", "-a",
-        action="store_true",
-        help="Resolve all packages from config",
-    )
-    resolve_parser.add_argument(
-        "--config", "-c",
-        type=str,
-        help="Path to config file",
-    )
-
     # doctor command
     doctor_parser = subparsers.add_parser(
         "doctor",
@@ -127,18 +119,6 @@ def main(args: Optional[List[str]] = None) -> int:
         help="Path to config file",
     )
 
-    # list-packages command
-    list_parser = subparsers.add_parser(
-        "list-packages",
-        help="Show all packages in the built-in registry",
-        description="List CUDA packages that comfy-env knows how to install",
-    )
-    list_parser.add_argument(
-        "--json",
-        action="store_true",
-        help="Output as JSON",
-    )
-
     parsed = parser.parse_args(args)
 
     if parsed.command is None:
@@ -148,16 +128,14 @@ 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":
             return cmd_info(parsed)
-        elif parsed.command == "resolve":
-            return cmd_resolve(parsed)
         elif parsed.command == "doctor":
             return cmd_doctor(parsed)
-        elif parsed.command == "list-packages":
-            return cmd_list_packages(parsed)
         else:
             parser.print_help()
             return 1
@@ -183,7 +161,7 @@ cuda_version = "auto"
 pytorch_version = "auto"
 
 [environment.cuda]
-# CUDA packages from comfy-env registry
+# CUDA packages from https://pozzettiandrea.github.io/cuda-wheels/
 # Example: nvdiffrast = "0.4.0"
 
 [environment.packages]
@@ -205,6 +183,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 +253,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()
 
@@ -262,98 +287,10 @@ def cmd_info(args) -> int:
     return 0
 
 
-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
-
-    env = RuntimeEnv.detect()
-    packages = []
-
-    # Get packages from args or config
-    if args.all or (not args.packages and args.config):
-        if args.config:
-            config = load_env_from_file(Path(args.config))
-        else:
-            config = discover_env_config(Path.cwd())
-
-        if config and config.no_deps_requirements:
-            packages = config.no_deps_requirements
-        else:
-            print("No CUDA packages found in config", file=sys.stderr)
-            return 1
-    elif args.packages:
-        packages = args.packages
-    else:
-        print("Specify packages or use --all with a config file", file=sys.stderr)
-        return 1
-
-    print(f"Resolving wheels for: {env}")
-    print("=" * 60)
-
-    # Build template variables
-    vars_dict = env.as_dict()
-    if env.cuda_version:
-        vars_dict["cuda_short2"] = get_cuda_short2(env.cuda_version)
-
-    all_ok = True
-    for pkg_spec in packages:
-        package, version = parse_wheel_requirement(pkg_spec)
-        pkg_lower = package.lower()
-
-        try:
-            if pkg_lower in PACKAGE_REGISTRY:
-                config = PACKAGE_REGISTRY[pkg_lower]
-
-                if "wheel_template" in config:
-                    # Direct wheel URL template
-                    effective_version = version or config.get("default_version")
-                    if not effective_version:
-                        print(f"  {package}: No version specified (no default in registry)")
-                        all_ok = False
-                        continue
-
-                    vars_dict["version"] = effective_version
-                    url = _substitute_template(config["wheel_template"], vars_dict)
-                    print(f"  {package}=={effective_version}: resolved")
-                    print(f"    {url}")
-
-                elif "package_name" in config:
-                    # PyPI variant (e.g., spconv-cu124)
-                    pkg_name = _substitute_template(config["package_name"], vars_dict)
-                    pkg_spec = f"{pkg_name}=={version}" if version else pkg_name
-                    print(f"  {package}: installs as {pkg_spec} from PyPI")
-
-                else:
-                    print(f"  {package}: no wheel_template or package_name in registry")
-                    all_ok = False
-            else:
-                print(f"  {package}: NOT in registry")
-                print(f"    Add to [wheel_sources] in comfy-env.toml:")
-                print(f'    {package} = "https://example.com/{package}-{{version}}+cu{{cuda_short}}-{{py_tag}}-{{platform}}.whl"')
-                all_ok = False
-
-        except Exception as e:
-            print(f"  {package}: FAILED - {e}")
-            all_ok = False
-
-    return 0 if all_ok else 1
-
-
-def _substitute_template(template: str, vars_dict: dict) -> str:
-    """Substitute {var} placeholders in template."""
-    result = template
-    for key, value in vars_dict.items():
-        if value is not None:
-            result = result.replace(f"{{{key}}}", str(value))
-    return result
-
-
 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)
@@ -395,72 +332,5 @@ def cmd_doctor(args) -> int:
         return 0
 
 
-def cmd_list_packages(args) -> int:
-    """Handle list-packages command."""
-    from .registry import PACKAGE_REGISTRY
-
-    if args.json:
-        import json
-        result = {}
-        for name, config in PACKAGE_REGISTRY.items():
-            result[name] = {
-                "description": config.get("description", ""),
-            }
-            if "wheel_template" in config:
-                result[name]["wheel_template"] = config["wheel_template"]
-            if "package_name" in config:
-                result[name]["package_name"] = config["package_name"]
-            if "default_version" in config:
-                result[name]["default_version"] = config["default_version"]
-        print(json.dumps(result, indent=2))
-        return 0
-
-    print("Built-in CUDA Package Registry")
-    print("=" * 60)
-    print()
-    print("These packages can be installed by adding them to comfy-env.toml:")
-    print()
-    print("  [cuda]")
-    print('  nvdiffrast = "0.4.0"')
-    print('  torch-scatter = "2.1.2"')
-    print()
-    print("Or override with custom wheel source:")
-    print()
-    print("  [wheel_sources]")
-    print('  nvdiffrast = "https://my-mirror.com/nvdiffrast-{version}+cu{cuda_short}-{py_tag}-{platform}.whl"')
-    print()
-    print("-" * 60)
-
-    # Group by type
-    wheel_template_packages = []
-    package_name_packages = []
-
-    for name, config in PACKAGE_REGISTRY.items():
-        desc = config.get("description", "")
-        default = config.get("default_version", "")
-        if "wheel_template" in config:
-            wheel_template_packages.append((name, desc, default))
-        elif "package_name" in config:
-            package_name_packages.append((name, desc, config["package_name"]))
-
-    if wheel_template_packages:
-        print("\nDirect wheel URL packages:")
-        for name, desc, default in sorted(wheel_template_packages):
-            version_info = f" (default: {default})" if default else ""
-            print(f"  {name:20} - {desc}{version_info}")
-
-    if package_name_packages:
-        print("\nPyPI variant packages:")
-        for name, desc, pkg_template in sorted(package_name_packages):
-            print(f"  {name:20} - {desc}")
-            print(f"                       installs as: {pkg_template}")
-
-    print()
-    print("Template variables: {version}, {cuda_short}, {torch_mm}, {py_tag}, {platform}")
-    print("See README for full documentation on writing wheel templates.")
-    print()
-    return 0
-
-
 if __name__ == "__main__":
     sys.exit(main())

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",
+]