comfy-env 0.0.26__tar.gz → 0.0.28__tar.gz

{comfy_env-0.0.26 → comfy_env-0.0.28}/PKG-INFO

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

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

{comfy_env-0.0.26 → comfy_env-0.0.28}/src/comfy_env/install.py

@@ -24,7 +24,7 @@ import sys
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Set, Union
 
-from .env.config import IsolatedEnv, NodeReq, SystemConfig
+from .env.config import IsolatedEnv, LocalConfig, NodeReq, SystemConfig
 from .env.config_file import load_config, discover_config
 from .env.manager import IsolatedEnvManager
 from .errors import CUDANotFoundError, DependencyError, InstallError, WheelNotFoundError
@@ -175,20 +175,23 @@ def _install_node_dependencies(
 
 def install(
     config: Optional[Union[str, Path]] = None,
-    mode: str = "inplace",
     node_dir: Optional[Path] = None,
     log_callback: Optional[Callable[[str], None]] = None,
     dry_run: bool = False,
     verify_wheels: bool = False,
+    **kwargs,  # Accept but ignore deprecated 'mode' parameter
 ) -> bool:
     """
     Install dependencies from a comfy-env.toml configuration.
 
     This is the main entry point for installing CUDA dependencies.
+    Mode is auto-detected from config:
+    - [envname] with python = "X.X" → isolated (creates separate venv)
+    - [envname] without python → inplace (installs into current env)
+    - [local.cuda] → local (installs into current env)
 
     Args:
         config: Path to config file. If None, auto-discovers in node_dir.
-        mode: Installation mode - "inplace" (current env) or "isolated" (new venv).
         node_dir: Directory to search for config. Defaults to current directory.
         log_callback: Optional callback for logging. Defaults to print.
         dry_run: If True, show what would be installed without installing.
@@ -209,9 +212,6 @@ def install(
         # Explicit config file
         install(config="comfy-env.toml")
 
-        # Isolated mode
-        install(mode="isolated")
-
         # Dry run to see what would be installed
         install(dry_run=True)
     """
@@ -250,10 +250,18 @@ def install(
         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:
-        return _install_inplace(env_config, node_dir, log, dry_run, verify_wheels)
+    # Auto-detect mode based on config:
+    # - env_config.python set → isolated (creates separate venv)
+    # - env_config without python → inplace (installs into current env)
+    # - only [local.cuda] → local (installs into current env)
+    if env_config:
+        if env_config.python:
+            return _install_isolated(env_config, node_dir, log, dry_run)
+        else:
+            return _install_inplace(env_config, node_dir, log, dry_run, verify_wheels)
+    elif full_config.has_local:
+        # Handle [local.cuda] and [local.packages] without isolated env
+        return _install_local(full_config.local, node_dir, log, dry_run)
     else:
         return True
 
@@ -353,6 +361,63 @@ def _install_inplace(
     return True
 
 
+def _install_local(
+    local_config: LocalConfig,
+    node_dir: Path,
+    log: Callable[[str], None],
+    dry_run: bool,
+) -> bool:
+    """Install local packages into current environment (no isolated venv)."""
+    log("Installing local packages into host environment")
+
+    # Install MSVC runtime on Windows (required for CUDA/PyTorch native extensions)
+    if sys.platform == "win32":
+        log("Installing MSVC runtime for Windows...")
+        if not dry_run:
+            _pip_install(["msvc-runtime"], no_deps=False, log=log)
+
+    # Detect runtime environment
+    env = RuntimeEnv.detect()
+    log(f"Detected environment: {env}")
+
+    # Check CUDA requirement
+    if not env.cuda_version and local_config.cuda_packages:
+        raise CUDANotFoundError(package=", ".join(local_config.cuda_packages.keys()))
+
+    # Convert cuda_packages dict to list of specs
+    cuda_packages = []
+    for pkg, ver in local_config.cuda_packages.items():
+        if ver:
+            cuda_packages.append(f"{pkg}=={ver}")
+        else:
+            cuda_packages.append(pkg)
+
+    if dry_run:
+        log("\nDry run - would install:")
+        for pkg in cuda_packages:
+            log(f"  {pkg}")
+        if local_config.requirements:
+            log("  Regular packages:")
+            for pkg in local_config.requirements:
+                log(f"    {pkg}")
+        return True
+
+    # Install CUDA packages
+    if cuda_packages:
+        log(f"\nInstalling {len(cuda_packages)} CUDA packages...")
+        for req in cuda_packages:
+            package, version = parse_wheel_requirement(req)
+            _install_cuda_package(package, version, env, [], log)
+
+    # Install regular packages
+    if local_config.requirements:
+        log(f"\nInstalling {len(local_config.requirements)} regular packages...")
+        _pip_install(local_config.requirements, no_deps=False, log=log)
+
+    log("\nLocal installation complete!")
+    return True
+
+
 def _get_install_info(
     package: str,
     version: Optional[str],