comfy-env 0.0.18__py3-none-any.whl → 0.0.19__py3-none-any.whl

comfy_env/env/config.py

@@ -5,6 +5,18 @@ from pathlib import Path
 from typing import Dict, List, Optional
 
 
+@dataclass
+class SystemConfig:
+    """Configuration for system-level packages.
+
+    These are OS-level packages (apt, brew, etc.) that need to be installed
+    before Python packages can work properly.
+    """
+    linux: List[str] = field(default_factory=list)    # apt packages
+    darwin: List[str] = field(default_factory=list)   # brew packages (future)
+    windows: List[str] = field(default_factory=list)  # winget packages (future)
+
+
 @dataclass
 class LocalConfig:
     """Configuration for local (host environment) installs.
@@ -37,6 +49,7 @@ class EnvManagerConfig:
     Full configuration parsed from comfy-env.toml.
 
     Supports the v2 schema:
+        [system]            - System-level packages (apt, brew, etc.)
         [local.cuda]        - CUDA packages for host environment
         [local.packages]    - Regular packages for host environment
         [envname]           - Isolated env definition
@@ -45,11 +58,17 @@ class EnvManagerConfig:
         [node_reqs]         - Node dependencies
         [tools]             - External tools (e.g., blender = "4.2")
     """
+    system: SystemConfig = field(default_factory=SystemConfig)
     local: LocalConfig = field(default_factory=LocalConfig)
     envs: Dict[str, "IsolatedEnv"] = field(default_factory=dict)
     node_reqs: List[NodeReq] = field(default_factory=list)
     tools: Dict[str, ToolConfig] = field(default_factory=dict)
 
+    @property
+    def has_system(self) -> bool:
+        """Check if there are system packages to install."""
+        return bool(self.system.linux or self.system.darwin or self.system.windows)
+
     @property
     def has_local(self) -> bool:
         """Check if there are local packages to install."""

comfy_env/env/config_file.py

@@ -63,7 +63,7 @@ else:
     except ImportError:
         tomllib = None  # type: ignore
 
-from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, ToolConfig
+from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, SystemConfig, ToolConfig
 from .cuda_gpu_detection import detect_cuda_version
 
 
@@ -332,7 +332,7 @@ def _substitute_vars(s: str, variables: Dict[str, str]) -> str:
 # =============================================================================
 
 # Reserved table names that are NOT isolated environments
-RESERVED_TABLES = {"local", "node_reqs", "env", "packages", "sources", "cuda", "variables", "worker", "tools"}
+RESERVED_TABLES = {"local", "node_reqs", "env", "packages", "sources", "cuda", "variables", "worker", "tools", "system"}
 
 
 def load_config(
@@ -426,12 +426,14 @@ def _parse_full_config(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig
         return _convert_simple_to_full(data, base_dir)
 
     # Parse full schema
+    system = _parse_system_section(data.get("system", {}))
     local = _parse_local_section(data.get("local", {}))
     envs = _parse_env_sections(data, base_dir)
     node_reqs = _parse_node_reqs(data.get("node_reqs", {}))
     tools = _parse_tools_section(data.get("tools", {}))
 
     return EnvManagerConfig(
+        system=system,
         local=local,
         envs=envs,
         node_reqs=node_reqs,
@@ -613,6 +615,34 @@ def _parse_tools_section(tools_data: Dict[str, Any]) -> Dict[str, ToolConfig]:
     return tools
 
 
+def _parse_system_section(system_data: Dict[str, Any]) -> SystemConfig:
+    """Parse [system] section.
+
+    Supports:
+        [system]
+        linux = ["libgl1", "libopengl0"]
+        darwin = ["mesa"]  # future
+        windows = ["vcredist"]  # future
+    """
+    linux = system_data.get("linux", [])
+    darwin = system_data.get("darwin", [])
+    windows = system_data.get("windows", [])
+
+    # Ensure all are lists
+    if not isinstance(linux, list):
+        linux = [linux] if linux else []
+    if not isinstance(darwin, list):
+        darwin = [darwin] if darwin else []
+    if not isinstance(windows, list):
+        windows = [windows] if windows else []
+
+    return SystemConfig(
+        linux=linux,
+        darwin=darwin,
+        windows=windows,
+    )
+
+
 def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
     """Convert simple config format to full EnvManagerConfig.
 
@@ -622,8 +652,9 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
     # Parse using simple parser to get IsolatedEnv
     simple_env = _parse_config(data, base_dir)
 
-    # Parse tools section (shared between simple and full format)
+    # Parse tools and system sections (shared between simple and full format)
     tools = _parse_tools_section(data.get("tools", {}))
+    system = _parse_system_section(data.get("system", {}))
 
     # Check if this has explicit env settings (isolated venv) vs just CUDA packages (local install)
     env_section = data.get("env", {})
@@ -632,6 +663,7 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
     if has_explicit_env:
         # Isolated venv config
         return EnvManagerConfig(
+            system=system,
             local=LocalConfig(),
             envs={simple_env.name: simple_env},
             node_reqs=[],
@@ -648,6 +680,7 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
                 cuda_packages[req] = ""
 
         return EnvManagerConfig(
+            system=system,
             local=LocalConfig(
                 cuda_packages=cuda_packages,
                 requirements=simple_env.requirements,

comfy_env/install.py

@@ -24,13 +24,111 @@ import sys
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Union
 
-from .env.config import IsolatedEnv, ToolConfig
+from .env.config import IsolatedEnv, SystemConfig
 from .env.config_file import discover_env_config, load_env_from_file, 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 .resolver import RuntimeEnv, WheelResolver, parse_wheel_requirement
-from .tools import install_tool
+
+
+def _install_system_packages(
+    system_config: SystemConfig,
+    log: Callable[[str], None],
+    dry_run: bool = False,
+) -> bool:
+    """
+    Install system-level packages (apt, brew, etc.).
+
+    Args:
+        system_config: SystemConfig with package lists per OS.
+        log: Logging callback.
+        dry_run: If True, show what would be installed without installing.
+
+    Returns:
+        True if installation succeeded or no packages needed.
+    """
+    platform = sys.platform
+
+    if platform.startswith("linux"):
+        packages = system_config.linux
+        if not packages:
+            return True
+
+        log(f"Installing {len(packages)} system package(s) via apt...")
+
+        if dry_run:
+            log(f"  Would install: {', '.join(packages)}")
+            return True
+
+        # Check if apt-get is available
+        if not shutil.which("apt-get"):
+            log("  Warning: apt-get not found. Cannot install system packages.")
+            log(f"  Please install manually: {', '.join(packages)}")
+            return True  # Don't fail - just warn
+
+        # Check if we can use sudo
+        sudo_available = shutil.which("sudo") is not None
+
+        try:
+            if sudo_available:
+                # Try with sudo
+                log("  Running apt-get update...")
+                update_result = subprocess.run(
+                    ["sudo", "apt-get", "update"],
+                    capture_output=True,
+                    text=True,
+                )
+                if update_result.returncode != 0:
+                    log(f"  Warning: apt-get update failed: {update_result.stderr.strip()}")
+                    # Continue anyway - packages might already be cached
+
+                log(f"  Installing: {', '.join(packages)}")
+                install_cmd = ["sudo", "apt-get", "install", "-y"] + packages
+                install_result = subprocess.run(
+                    install_cmd,
+                    capture_output=True,
+                    text=True,
+                )
+
+                if install_result.returncode != 0:
+                    log(f"  Warning: apt-get install failed: {install_result.stderr.strip()}")
+                    log(f"  Please install manually: sudo apt-get install {' '.join(packages)}")
+                    return True  # Don't fail - just warn
+                else:
+                    log("  System packages installed successfully.")
+                    return True
+            else:
+                log("  Warning: sudo not available. Cannot install system packages automatically.")
+                log(f"  Please install manually: sudo apt-get install {' '.join(packages)}")
+                return True  # Don't fail - just warn
+
+        except Exception as e:
+            log(f"  Warning: Failed to install system packages: {e}")
+            log(f"  Please install manually: sudo apt-get install {' '.join(packages)}")
+            return True  # Don't fail - just warn
+
+    elif platform == "darwin":
+        packages = system_config.darwin
+        if not packages:
+            return True
+
+        log(f"System packages for macOS: {', '.join(packages)}")
+        log("  Note: macOS system package installation not yet implemented.")
+        log(f"  Please install manually with Homebrew: brew install {' '.join(packages)}")
+        return True
+
+    elif platform == "win32":
+        packages = system_config.windows
+        if not packages:
+            return True
+
+        log(f"System packages for Windows: {', '.join(packages)}")
+        log("  Note: Windows system package installation not yet implemented.")
+        log(f"  Please install manually.")
+        return True
+
+    return True
 
 
 def install(
@@ -86,16 +184,10 @@ def install(
             "Create comfy-env.toml or specify path explicitly."
         )
 
-    # Install tools first (e.g., Blender)
-    # Tools are installed to ComfyUI root (shared across all nodes)
-    if full_config.tools:
-        log(f"Installing {len(full_config.tools)} tool(s)...")
-        comfyui_root = node_dir.parent.parent  # custom_nodes/../.. = ComfyUI/
-        for name, tool_config in full_config.tools.items():
-            if dry_run:
-                log(f"  Would install {name} {tool_config.version}")
-            else:
-                install_tool(tool_config, log, comfyui_root)
+    # Install system packages first (apt, brew, etc.)
+    # These need to be installed before Python packages that depend on them
+    if full_config.has_system:
+        _install_system_packages(full_config.system, log, dry_run)
 
     # Get environment config
     env_config = full_config.default_env

{comfy_env-0.0.18.dist-info → comfy_env-0.0.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.18
+Version: 0.0.19
 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.18.dist-info → comfy_env-0.0.19.dist-info}/RECORD

@@ -2,13 +2,12 @@ comfy_env/__init__.py,sha256=76gIAh7qFff_v_bAolXVzuWzcgvD3bp-yQGCNzba_Iw,3287
 comfy_env/cli.py,sha256=X-GCQMP0mtMcE3ZgkT-VLQ4Gq3UUvcb_Ux_NClEFhgI,15975
 comfy_env/decorator.py,sha256=FwM6O0eIYK1FlKmniE4sJyzLLIr4mVg3ON-PnuTF2cw,16056
 comfy_env/errors.py,sha256=8hN8NDlo8oBUdapc-eT3ZluigI5VBzfqsSBvQdfWlz4,9943
-comfy_env/install.py,sha256=K0sayQ8HVG5t7XpxrAouhicFYnqSXpaQeDa5DgHO6L4,21064
+comfy_env/install.py,sha256=txjQh5mdtFt0uQL7682LWgH0-311TflunaKv-n0XlYM,24510
 comfy_env/registry.py,sha256=uFCtGmWYvwGCqObXgzmArX7o5JsFNsHXxayofk3m6no,2569
 comfy_env/resolver.py,sha256=l-AnmCE1puG6CvdpDB-KrsfG_cn_3uO2DryYizUnG_4,12474
-comfy_env/tools.py,sha256=mFNB_uq64ON5hlreH_0wTLONahDo3pBHxhQYTcTHxXE,6554
 comfy_env/env/__init__.py,sha256=imQdoQEQvrRT-QDtyNpFlkVbm2fBzgACdpQwRPd09fI,1157
-comfy_env/env/config.py,sha256=h2EJqg1bf5GamBwXV2uXeYZ4fBpW9nqs0WG1Xzlqjmc,5978
-comfy_env/env/config_file.py,sha256=tJ9xfmf2RghzK6PUxwTrhpvqV_5pecjC6IYYBoZ0U58,21890
+comfy_env/env/config.py,sha256=r1olWRFbXzSSU24Zkn_TVFVujaf_lEX6LAYEgfBYo3U,6765
+comfy_env/env/config_file.py,sha256=-NdK6i0LKKGK6uNqXKvBlQGnwdHpMCaNkYpbxLDAgNY,22918
 comfy_env/env/cuda_gpu_detection.py,sha256=YLuXUdWg6FeKdNyLlQAHPlveg4rTenXJ2VbeAaEi9QE,9755
 comfy_env/env/manager.py,sha256=bbV1MpURNGuBJ1sSWg_2oSU0J-dW-FhBCuHHHQxgrSM,24785
 comfy_env/env/security.py,sha256=dNSitAnfBNVdvxgBBntYw33AJaCs_S1MHb7KJhAVYzM,8171
@@ -33,8 +32,8 @@ comfy_env/workers/tensor_utils.py,sha256=TCuOAjJymrSbkgfyvcKtQ_KbVWTqSwP9VH_bCaF
 comfy_env/workers/torch_mp.py,sha256=1cNhcrCWZ9E6AHCIEMC3vDLo_qjyV2wuQh5iZslg0Hg,13222
 comfy_env/workers/venv.py,sha256=_ekHfZPqBIPY08DjqiXm6cTBQH4DrbxRWR3AAv3mit8,31589
 comfy_env/wheel_sources.yml,sha256=nSZ8XB_I5JXQGB7AgC6lHs_IXMd9Kcno10artNL8BKw,7775
-comfy_env-0.0.18.dist-info/METADATA,sha256=2AL5DPZlU5EXPmtM9OhEt-FZ8wlIw6lzs5kGMGW4dKI,5399
-comfy_env-0.0.18.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.0.18.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.0.18.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.0.18.dist-info/RECORD,,
+comfy_env-0.0.19.dist-info/METADATA,sha256=5L7G8zHaCX2gtDMpdadBG15csEsdHqsTm5HOeowTaSI,5399
+comfy_env-0.0.19.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.0.19.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.0.19.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.0.19.dist-info/RECORD,,

comfy_env/tools.py

@@ -1,221 +0,0 @@
-"""
-Tool installers for external dependencies like Blender.
-
-Usage in comfy-env.toml:
-    [tools]
-    blender = "4.2"
-"""
-
-import os
-import platform
-import shutil
-import subprocess
-import tarfile
-import zipfile
-from pathlib import Path
-from typing import Callable, Optional
-from urllib.request import urlretrieve
-
-from .env.config import ToolConfig
-
-# Default install location
-DEFAULT_TOOLS_DIR = Path.home() / ".comfy-env" / "tools"
-
-# Blender download URLs by platform and version
-BLENDER_DOWNLOADS = {
-    "4.2": {
-        "linux": "https://download.blender.org/release/Blender4.2/blender-4.2.0-linux-x64.tar.xz",
-        "windows": "https://download.blender.org/release/Blender4.2/blender-4.2.0-windows-x64.zip",
-        "darwin": "https://download.blender.org/release/Blender4.2/blender-4.2.0-macos-arm64.dmg",
-    },
-    "4.3": {
-        "linux": "https://download.blender.org/release/Blender4.3/blender-4.3.0-linux-x64.tar.xz",
-        "windows": "https://download.blender.org/release/Blender4.3/blender-4.3.0-windows-x64.zip",
-        "darwin": "https://download.blender.org/release/Blender4.3/blender-4.3.0-macos-arm64.dmg",
-    },
-}
-
-
-def get_platform() -> str:
-    """Get current platform name."""
-    system = platform.system().lower()
-    if system == "linux":
-        return "linux"
-    elif system == "windows":
-        return "windows"
-    elif system == "darwin":
-        return "darwin"
-    return system
-
-
-def install_tool(
-    config: ToolConfig,
-    log: Callable[[str], None] = print,
-    base_dir: Optional[Path] = None,
-) -> Optional[Path]:
-    """Install a tool based on its config.
-
-    Args:
-        config: Tool configuration
-        log: Logging callback
-        base_dir: Base directory for tools. Tools install to base_dir/tools/<name>/
-    """
-    if config.name.lower() == "blender":
-        return install_blender(config.version, log, config.install_dir or base_dir)
-    else:
-        log(f"Unknown tool: {config.name}")
-        return None
-
-
-def install_blender(
-    version: str = "4.2",
-    log: Callable[[str], None] = print,
-    base_dir: Optional[Path] = None,
-) -> Optional[Path]:
-    """
-    Install Blender to the specified directory.
-
-    Args:
-        version: Blender version to install (e.g., "4.2")
-        log: Logging callback
-        base_dir: Base directory. Blender installs to base_dir/tools/blender/
-                  If None, uses ~/.comfy-env/tools/blender/
-
-    Returns path to blender executable if successful.
-    """
-    plat = get_platform()
-    if base_dir:
-        install_dir = base_dir / "tools" / "blender"
-    else:
-        install_dir = DEFAULT_TOOLS_DIR / "blender"
-
-    # Check if already installed
-    exe = find_blender(install_dir)
-    if exe:
-        log(f"Blender already installed: {exe}")
-        return exe
-
-    # Get download URL
-    if version not in BLENDER_DOWNLOADS:
-        log(f"Unknown Blender version: {version}. Available: {list(BLENDER_DOWNLOADS.keys())}")
-        return None
-
-    urls = BLENDER_DOWNLOADS[version]
-    if plat not in urls:
-        log(f"Blender {version} not available for {plat}")
-        return None
-
-    url = urls[plat]
-    log(f"Downloading Blender {version} for {plat}...")
-
-    install_dir.mkdir(parents=True, exist_ok=True)
-    archive_name = url.split("/")[-1]
-    archive_path = install_dir / archive_name
-
-    try:
-        # Download
-        urlretrieve(url, archive_path)
-        log(f"Downloaded to {archive_path}")
-
-        # Extract
-        log("Extracting...")
-        if archive_name.endswith(".tar.xz"):
-            with tarfile.open(archive_path, "r:xz") as tar:
-                tar.extractall(install_dir)
-        elif archive_name.endswith(".zip"):
-            with zipfile.ZipFile(archive_path, "r") as zf:
-                zf.extractall(install_dir)
-        elif archive_name.endswith(".dmg"):
-            # macOS DMG requires special handling
-            log("macOS DMG installation not yet automated. Please install manually.")
-            archive_path.unlink()
-            return None
-
-        # Clean up archive
-        archive_path.unlink()
-
-        # Find the executable
-        exe = find_blender(install_dir)
-        if exe:
-            log(f"Blender installed: {exe}")
-            return exe
-        else:
-            log("Blender extracted but executable not found")
-            return None
-
-    except Exception as e:
-        log(f"Failed to install Blender: {e}")
-        if archive_path.exists():
-            archive_path.unlink()
-        return None
-
-
-def find_blender(search_dir: Optional[Path] = None) -> Optional[Path]:
-    """Find Blender executable."""
-    # Check PATH first
-    blender_in_path = shutil.which("blender")
-    if blender_in_path:
-        return Path(blender_in_path)
-
-    # Check common locations
-    plat = get_platform()
-    search_paths = []
-
-    if search_dir:
-        search_paths.append(search_dir)
-
-    search_paths.append(DEFAULT_TOOLS_DIR / "blender")
-
-    if plat == "windows":
-        search_paths.extend([
-            Path(os.environ.get("ProgramFiles", "C:/Program Files")) / "Blender Foundation",
-            Path.home() / "AppData" / "Local" / "Blender Foundation",
-        ])
-    elif plat == "linux":
-        search_paths.extend([
-            Path("/opt/blender"),
-            Path.home() / "blender",
-        ])
-    elif plat == "darwin":
-        search_paths.append(Path("/Applications/Blender.app/Contents/MacOS"))
-
-    exe_name = "blender.exe" if plat == "windows" else "blender"
-
-    for base in search_paths:
-        if not base.exists():
-            continue
-        # Direct check
-        exe = base / exe_name
-        if exe.exists():
-            return exe
-        # Search subdirectories (for extracted archives like blender-4.2.0-linux-x64/)
-        for subdir in base.iterdir():
-            if subdir.is_dir():
-                exe = subdir / exe_name
-                if exe.exists():
-                    return exe
-
-    return None
-
-
-def ensure_blender(
-    version: str = "4.2",
-    log: Callable[[str], None] = print,
-    base_dir: Optional[Path] = None,
-) -> Optional[Path]:
-    """Ensure Blender is installed, installing if necessary.
-
-    Args:
-        version: Blender version to install
-        log: Logging callback
-        base_dir: Base directory. Searches/installs in base_dir/tools/blender/
-    """
-    if base_dir:
-        search_dir = base_dir / "tools" / "blender"
-    else:
-        search_dir = DEFAULT_TOOLS_DIR / "blender"
-
-    exe = find_blender(search_dir)
-    if exe:
-        return exe
-    return install_blender(version, log, base_dir)