comfy-env 0.0.17__tar.gz → 0.0.19__tar.gz

{comfy_env-0.0.17 → comfy_env-0.0.19}/PKG-INFO

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

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

{comfy_env-0.0.17 → comfy_env-0.0.19}/src/comfy_env/cli.py

@@ -47,7 +47,7 @@ def main(args: Optional[List[str]] = None) -> int:
     install_parser = subparsers.add_parser(
         "install",
         help="Install dependencies from config",
-        description="Install CUDA wheels and dependencies from comfyui_env.toml",
+        description="Install CUDA wheels and dependencies from comfy-env.toml",
     )
     install_parser.add_argument(
         "--config", "-c",
@@ -450,7 +450,7 @@ def cmd_list_packages(args) -> int:
     print("=" * 60)
     print()
     print("These packages can be installed without specifying wheel_sources.")
-    print("Just add them to your comfyui_env.toml:")
+    print("Just add them to your comfy-env.toml:")
     print()
     print("  [cuda]")
     print("  torch-scatter = \"2.1.2\"")

{comfy_env-0.0.17 → comfy_env-0.0.19}/src/comfy_env/decorator.py

@@ -153,7 +153,7 @@ def _get_or_create_worker(config: WorkerConfig, log_fn: Callable):
             # Same Python - use TorchMPWorker (fast, zero-copy)
             from .workers import TorchMPWorker
             log_fn(f"Creating TorchMPWorker (same Python, zero-copy tensors)")
-            worker = TorchMPWorker(name=config.env_name)
+            worker = TorchMPWorker(name=config.env_name, sys_path=config.sys_path)
         else:
             # Different Python - use PersistentVenvWorker
             from .workers.venv import PersistentVenvWorker
@@ -369,6 +369,11 @@ def isolated(
                 # Get module name for import in worker
                 module_name = cls.__module__
 
+                # Handle ComfyUI's dynamic import which can set __module__ to a path
+                if module_name.startswith('/') or module_name.startswith('\\'):
+                    # Module name is a filesystem path - use the source file stem instead
+                    module_name = source_file.stem
+
                 # Call worker using appropriate method
                 if worker_config.python is None:
                     # TorchMPWorker - use call_method protocol (avoids pickle issues)

{comfy_env-0.0.17 → comfy_env-0.0.19}/src/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.
@@ -34,9 +46,10 @@ class ToolConfig:
 @dataclass
 class EnvManagerConfig:
     """
-    Full configuration parsed from comfyui_env.toml.
+    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-0.0.17 → comfy_env-0.0.19}/src/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-0.0.17 → comfy_env-0.0.19}/src/comfy_env/install.py

@@ -12,10 +12,10 @@ Example:
     install()
 
     # In-place with explicit config
-    install(config="comfyui_env.toml", mode="inplace")
+    install(config="comfy-env.toml", mode="inplace")
 
     # Isolated environment
-    install(config="comfyui_env.toml", mode="isolated")
+    install(config="comfy-env.toml", mode="isolated")
 """
 
 import shutil
@@ -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(
@@ -42,7 +140,7 @@ def install(
     verify_wheels: bool = False,
 ) -> bool:
     """
-    Install dependencies from a comfyui_env.toml configuration.
+    Install dependencies from a comfy-env.toml configuration.
 
     This is the main entry point for installing CUDA dependencies.
 
@@ -67,7 +165,7 @@ def install(
         install()
 
         # Explicit config file
-        install(config="comfyui_env.toml")
+        install(config="comfy-env.toml")
 
         # Isolated mode
         install(mode="isolated")
@@ -83,19 +181,13 @@ def install(
     if full_config is None:
         raise FileNotFoundError(
             "No configuration file found. "
-            "Create comfyui_env.toml or specify path explicitly."
+            "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.17 → comfy_env-0.0.19}/src/comfy_env/workers/torch_mp.py

@@ -40,7 +40,7 @@ _SHUTDOWN = object()
 _CALL_METHOD = "call_method"
 
 
-def _worker_loop(queue_in, queue_out):
+def _worker_loop(queue_in, queue_out, sys_path_additions=None):
     """
     Worker process main loop.
 
@@ -54,10 +54,22 @@ def _worker_loop(queue_in, queue_out):
     import importlib
     import os
     import sys
+    from pathlib import Path
 
     # Set worker mode env var
     os.environ["COMFYUI_ISOLATION_WORKER"] = "1"
 
+    # Add stubs directory for folder_paths etc. (same as PersistentVenvWorker)
+    stubs_dir = Path(__file__).parent.parent / "stubs"
+    if str(stubs_dir) not in sys.path:
+        sys.path.insert(0, str(stubs_dir))
+
+    # Add custom paths to sys.path for module discovery
+    if sys_path_additions:
+        for path in sys_path_additions:
+            if path not in sys.path:
+                sys.path.insert(0, path)
+
     while True:
         try:
             item = queue_in.get()
@@ -151,14 +163,16 @@ class TorchMPWorker(Worker):
     interpreter without inherited state from the parent.
     """
 
-    def __init__(self, name: Optional[str] = None):
+    def __init__(self, name: Optional[str] = None, sys_path: Optional[list] = None):
         """
         Initialize the worker.
 
         Args:
             name: Optional name for logging/debugging.
+            sys_path: Optional list of paths to add to sys.path in worker process.
         """
         self.name = name or "TorchMPWorker"
+        self._sys_path = sys_path or []
         self._process = None
         self._queue_in = None
         self._queue_out = None
@@ -185,7 +199,7 @@ class TorchMPWorker(Worker):
         self._queue_out = ctx.Queue()
         self._process = ctx.Process(
             target=_worker_loop,
-            args=(self._queue_in, self._queue_out),
+            args=(self._queue_in, self._queue_out, self._sys_path),
             daemon=True,
         )
         self._process.start()

comfy_env-0.0.17/CLAUDE.md

@@ -1,131 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code when working with this repository.
-
-## Project Overview
-
-**comfy-env** is a Python library for ComfyUI custom nodes that provides:
-
-1. **CUDA Wheel Resolution** - Deterministic wheel URL construction for CUDA packages (nvdiffrast, pytorch3d, etc.)
-2. **In-Place Installation** - Install CUDA wheels into current environment without compile
-3. **Process Isolation** - Run nodes in separate venvs with different dependencies
-
-## Architecture
-
-### Type 1 Nodes (Isolated Venv)
-Nodes that need separate venv due to conflicting dependencies:
-```
-ComfyUI Main Process                    Isolated Subprocess
-┌─────────────────────────┐            ┌──────────────────────────┐
-│  @isolated decorator    │            │  runner.py entrypoint    │
-│  intercepts FUNCTION    │   UDS/     │                          │
-│  method calls           │  stdin ──► │  Imports node module     │
-│                         │            │  (decorator is no-op)    │
-│  Tensor IPC via shared  │            │                          │
-│  memory / CUDA IPC      │ ◄──────────│  Returns result          │
-└─────────────────────────┘            └──────────────────────────┘
-```
-
-### Type 2 Nodes (In-Place)
-Nodes that just need CUDA wheels resolved:
-```
-comfy-env.toml
-       │
-       ▼
-┌──────────────────────────────────────────────┐
-│  WheelResolver                               │
-│  - Detects CUDA/PyTorch/Python versions      │
-│  - Constructs exact wheel URLs               │
-│  - pip install --no-deps                     │
-└──────────────────────────────────────────────┘
-```
-
-## Key Components
-
-| File | Purpose |
-|------|---------|
-| `src/comfy_env/install.py` | `install()` function for both modes |
-| `src/comfy_env/resolver.py` | Wheel URL resolution with template expansion |
-| `src/comfy_env/cli.py` | `comfy-env` CLI commands |
-| `src/comfy_env/decorator.py` | `@isolated` decorator for process isolation |
-| `src/comfy_env/workers/` | Worker classes (TorchMPWorker, VenvWorker) |
-| `src/comfy_env/env/manager.py` | venv creation with `uv` |
-| `src/comfy_env/env/config_file.py` | TOML config parsing |
-
-## Development Commands
-
-```bash
-# Install in development mode
-cd /home/shadeform/comfy-env
-pip install -e .
-
-# Run CLI
-comfy-env info
-comfy-env install --dry-run
-comfy-env resolve nvdiffrast==0.4.0
-```
-
-## Usage Patterns
-
-### In-Place Installation (Type 2)
-```python
-from comfy_env import install
-
-# Auto-discover config and install
-install()
-
-# Dry run
-install(dry_run=True)
-```
-
-### Process Isolation (Type 1)
-```python
-from comfy_env import isolated
-
-@isolated(env="myenv")
-class MyGPUNode:
-    FUNCTION = "process"
-    RETURN_TYPES = ("IMAGE",)
-
-    def process(self, image):
-        # Runs in isolated subprocess
-        import heavy_dependency
-        return (result,)
-```
-
-### Direct Worker Usage
-```python
-from comfy_env import TorchMPWorker
-
-worker = TorchMPWorker()
-result = worker.call(my_function, image=tensor)
-```
-
-## Config File Format
-
-```toml
-[env]
-name = "my-node"
-python = "3.10"
-cuda = "auto"
-
-[packages]
-requirements = ["transformers>=4.56"]
-no_deps = ["nvdiffrast==0.4.0"]
-
-[sources]
-wheel_sources = ["https://github.com/.../releases/download/"]
-```
-
-## Key Design Decisions
-
-1. **Deterministic Resolution**: Wheel URLs are constructed, not solved. If URL 404s, fail fast with clear message.
-
-2. **No Compilation on User Machines**: If wheel doesn't exist, fail with actionable error showing what combos are available.
-
-3. **Template Variables**: `{cuda_short}`, `{torch_mm}`, `{py_short}`, `{platform}` for URL construction.
-
-## Related Projects
-
-- **pyisolate** - ComfyUI's official security-focused isolation
-- **comfy-cli** - High-level ComfyUI management