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

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

@@ -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 → comfy_env-0.0.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfy-env"
-version = "0.0.18"
+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.18 → 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.
@@ -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-0.0.18 → 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.18 → comfy_env-0.0.19}/src/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/examples/basic_node/__init__.py

@@ -1,5 +0,0 @@
-"""Example ComfyUI node using process isolation."""
-
-from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
-
-__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]

comfy_env-0.0.18/examples/basic_node/comfy-env.toml

@@ -1,65 +0,0 @@
-# Example isolation configuration for a ComfyUI custom node.
-#
-# This file defines the isolated Python environment for your node.
-# The comfyui-isolation library will auto-discover this file.
-#
-# Usage in your node:
-#     bridge = WorkerBridge.from_config_file(
-#         node_dir=Path(__file__).parent,
-#         worker_script=Path(__file__).parent / "worker.py",
-#     )
-
-[env]
-# Unique name for this environment (used for caching)
-name = "example-node"
-
-# Python version
-python = "3.10"
-
-# CUDA version: "auto" (detect), "12.4", "12.8", or null (CPU only)
-cuda = "auto"
-
-# Optional: specific PyTorch version (if not specified, latest from index is used)
-# pytorch_version = "2.4.1"
-
-
-[packages]
-# Required packages
-requirements = [
-    "torch",
-    "torchvision",
-    "pillow",
-    "numpy",
-]
-
-# Optional: path to additional requirements.txt (relative to this file's directory)
-# requirements_file = "requirements.txt"
-
-
-[sources]
-# Custom wheel repositories (passed as --find-links to pip)
-# wheel_sources = [
-#     "https://my-custom-wheels.github.io/",
-# ]
-
-# Extra package indexes (passed as --extra-index-url to pip)
-# index_urls = [
-#     "https://test.pypi.org/simple/",
-# ]
-
-
-[variables]
-# Define variables for substitution in requirements.
-# You can reference these with {variable_name} syntax.
-#
-# Auto-populated variables (no need to define):
-#   {cuda_version} - e.g., "12.4"
-#   {cuda_short} - e.g., "124"
-#   {pytorch_version} - e.g., "2.9.1"
-#   {pytorch_short} - e.g., "291" (version without dots)
-#   {pytorch_mm} - e.g., "29" (major.minor without dot, for wheel names)
-#
-# Example:
-#   pytorch_version = "2.4.1"
-#   pytorch3d_version = "0.7.8+5043d15pt{pytorch_version}cu{cuda_short}"
-#   flex_gemm = "0.0.1+cu{cuda_short}torch{pytorch_mm}"

comfy_env-0.0.18/examples/basic_node/nodes.py

@@ -1,157 +0,0 @@
-"""
-Example ComfyUI node that uses process isolation.
-
-This demonstrates how to use comfyui-isolation in a ComfyUI custom node.
-
-Two approaches are shown:
-1. Programmatic configuration (IsolatedEnv directly in code)
-2. Declarative configuration (comfy_env_reqs.toml file)
-"""
-
-from pathlib import Path
-from comfy_env import IsolatedEnv, WorkerBridge, detect_cuda_version
-
-# Get the node's root directory
-NODE_ROOT = Path(__file__).parent
-
-
-# ===========================================================================
-# APPROACH 1: Programmatic Configuration (traditional)
-# ===========================================================================
-# Define the isolated environment configuration in code
-ENV_CONFIG = IsolatedEnv(
-    name="example-node",
-    python="3.10",
-    cuda=detect_cuda_version(),  # Auto-detect (12.8 for Blackwell, 12.4 for others)
-    requirements=[
-        "torch",
-        "torchvision",
-        "pillow",
-        "numpy",
-    ],
-    # Add custom wheel sources if needed:
-    # wheel_sources=["https://my-wheels.github.io/"],
-)
-
-# Create bridge singleton
-_bridge = None
-
-
-def get_bridge() -> WorkerBridge:
-    """Get or create the worker bridge singleton (programmatic approach)."""
-    global _bridge
-    if _bridge is None:
-        _bridge = WorkerBridge(
-            env=ENV_CONFIG,
-            worker_script=NODE_ROOT / "worker.py",
-            base_dir=NODE_ROOT,
-        )
-    return _bridge
-
-
-# ===========================================================================
-# APPROACH 2: Declarative Configuration (recommended for new projects)
-# ===========================================================================
-# Instead of the above, you can use a comfy_env_reqs.toml file:
-#
-# def get_bridge() -> WorkerBridge:
-#     """Get or create the worker bridge singleton (config file approach)."""
-#     global _bridge
-#     if _bridge is None:
-#         _bridge = WorkerBridge.from_config_file(
-#             node_dir=NODE_ROOT,
-#             worker_script=NODE_ROOT / "worker.py",
-#         )
-#     return _bridge
-#
-# This auto-discovers comfy_env_reqs.toml in the node directory.
-# See the example file in this directory for the format.
-
-
-class IsolatedProcessorNode:
-    """
-    Example node that processes images in an isolated environment.
-
-    This node runs inference in a separate Python process with its own
-    dependencies, avoiding conflicts with ComfyUI's environment.
-    """
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "scale": ("FLOAT", {"default": 1.0, "min": 0.1, "max": 10.0}),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "process"
-    CATEGORY = "example/isolation"
-
-    def process(self, image, scale):
-        """Process image in isolated environment."""
-        import torch
-        import numpy as np
-        from PIL import Image
-
-        bridge = get_bridge()
-
-        # Ensure environment is set up (first run only)
-        bridge.ensure_environment(verify_packages=["torch"])
-
-        # Convert ComfyUI image format to PIL
-        # ComfyUI uses (B, H, W, C) float32 tensors
-        img_np = (image[0].numpy() * 255).astype(np.uint8)
-        pil_image = Image.fromarray(img_np)
-
-        # Call worker method
-        result = bridge.call("process_image", image=pil_image, scale=scale)
-
-        # Convert back to ComfyUI format
-        result_np = np.array(result).astype(np.float32) / 255.0
-        result_tensor = torch.from_numpy(result_np).unsqueeze(0)
-
-        return (result_tensor,)
-
-
-class SetupIsolatedEnvNode:
-    """
-    Node to set up the isolated environment.
-
-    Run this once to create the environment before using other nodes.
-    """
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "trigger": ("*",),  # Any input to trigger
-            }
-        }
-
-    RETURN_TYPES = ("STRING",)
-    FUNCTION = "setup"
-    CATEGORY = "example/isolation"
-
-    def setup(self, trigger):
-        """Set up the isolated environment."""
-        bridge = get_bridge()
-
-        try:
-            bridge.ensure_environment(verify_packages=["torch", "numpy"])
-            return (f"Environment ready: {bridge.python_exe}",)
-        except Exception as e:
-            return (f"Setup failed: {e}",)
-
-
-# Node class mappings for ComfyUI
-NODE_CLASS_MAPPINGS = {
-    "IsolatedProcessorExample": IsolatedProcessorNode,
-    "SetupIsolatedEnvExample": SetupIsolatedEnvNode,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "IsolatedProcessorExample": "Isolated Processor (Example)",
-    "SetupIsolatedEnvExample": "Setup Isolated Env (Example)",
-}

comfy_env-0.0.18/examples/basic_node/worker.py

@@ -1,79 +0,0 @@
-"""
-Example worker script for isolated environment.
-
-This runs in the isolated Python environment and handles inference requests.
-"""
-
-from comfy_env import BaseWorker, register
-
-
-class ExampleWorker(BaseWorker):
-    """Example worker that processes images."""
-
-    def setup(self):
-        """Called once when worker starts - load models here."""
-        self.log("Loading model...")
-
-        # Import heavy dependencies only in the isolated env
-        import torch
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.log(f"Using device: {self.device}")
-
-        # In a real node, you'd load your model here:
-        # self.model = load_my_model().to(self.device)
-
-        self.log("Model loaded!")
-
-    @register("echo")
-    def echo(self, message: str):
-        """Simple echo for testing."""
-        return f"Echo: {message}"
-
-    @register("process_image")
-    def process_image(self, image, scale: float = 1.0):
-        """
-        Process an image.
-
-        Args:
-            image: PIL Image or numpy array
-            scale: Scale factor
-
-        Returns:
-            Processed image
-        """
-        import numpy as np
-        from PIL import Image
-
-        self.log(f"Processing image with scale={scale}")
-
-        # Convert to numpy if needed
-        if hasattr(image, 'save'):  # PIL Image
-            arr = np.array(image)
-        else:
-            arr = image
-
-        # Example processing: simple brightness adjustment
-        result = np.clip(arr * scale, 0, 255).astype(np.uint8)
-
-        self.log("Processing complete")
-        return Image.fromarray(result)
-
-    @register("gpu_info")
-    def get_gpu_info(self):
-        """Get GPU information from the isolated environment."""
-        import torch
-
-        if not torch.cuda.is_available():
-            return {"available": False}
-
-        return {
-            "available": True,
-            "device_count": torch.cuda.device_count(),
-            "device_name": torch.cuda.get_device_name(0),
-            "memory_allocated": torch.cuda.memory_allocated(0),
-            "memory_cached": torch.cuda.memory_reserved(0),
-        }
-
-
-if __name__ == "__main__":
-    ExampleWorker().run()

comfy_env-0.0.18/examples/decorator_node/__init__.py

@@ -1,9 +0,0 @@
-"""
-Example ComfyUI nodes using the @isolated decorator.
-
-This demonstrates the simplest way to run node methods in isolated subprocess.
-"""
-
-from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
-
-__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]

comfy_env-0.0.18/examples/decorator_node/nodes.py

@@ -1,182 +0,0 @@
-"""
-Example ComfyUI nodes using the @isolated decorator.
-
-This demonstrates the simplest possible way to run node methods in
-isolated subprocess environments. No separate worker file needed!
-
-The @isolated decorator:
-1. Extracts your method source code at class decoration time
-2. Auto-generates a worker file on first call
-3. Creates an isolated venv with your requirements
-4. Intercepts method calls and forwards to the subprocess
-5. Handles all serialization/deserialization automatically
-
-Compare this to examples/basic_node which uses the traditional approach
-with separate worker.py and explicit bridge management.
-"""
-
-from comfy_env import isolated
-
-
-# ===========================================================================
-# EXAMPLE 1: Simple inline requirements
-# ===========================================================================
-
-@isolated(
-    env="decorator-example",
-    requirements=["torch", "pillow", "numpy"],
-    python="3.10",
-    cuda="auto",  # Auto-detect GPU (12.8 for Blackwell, 12.4 for others)
-)
-class SimpleIsolatedNode:
-    """
-    Simplest possible isolated node - just add @isolated decorator!
-
-    The process() method body runs in a separate Python subprocess
-    with its own torch installation. The main ComfyUI process never
-    imports torch from this node.
-    """
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "brightness": ("FLOAT", {
-                    "default": 1.0,
-                    "min": 0.0,
-                    "max": 2.0,
-                    "step": 0.1,
-                }),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "process"
-    CATEGORY = "example/decorator"
-
-    def process(self, image, brightness):
-        # Everything below runs in isolated subprocess!
-        # These imports happen in the subprocess, not ComfyUI main process
-        import torch
-        import numpy as np
-
-        # The image arrives already deserialized as a torch tensor
-        # (comfyui-isolation handles ComfyUI IMAGE format automatically)
-
-        # Apply brightness adjustment
-        result = image * brightness
-        result = torch.clamp(result, 0.0, 1.0)
-
-        return (result,)
-
-
-# ===========================================================================
-# EXAMPLE 2: Multiple isolated methods
-# ===========================================================================
-
-@isolated(
-    env="multi-method-example",
-    requirements=["torch", "pillow", "numpy"],
-)
-class MultiMethodNode:
-    """
-    Node with multiple methods that all run in the isolated subprocess.
-
-    Use ISOLATED_METHODS to specify which methods should be isolated.
-    """
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image": ("IMAGE",),
-                "operation": (["invert", "grayscale", "double"],),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "process"
-    CATEGORY = "example/decorator"
-
-    # List all methods that should run in subprocess
-    ISOLATED_METHODS = ["process", "invert_image", "to_grayscale", "double_brightness"]
-
-    def process(self, image, operation):
-        import torch
-
-        if operation == "invert":
-            return self.invert_image(image)
-        elif operation == "grayscale":
-            return self.to_grayscale(image)
-        else:
-            return self.double_brightness(image)
-
-    def invert_image(self, image):
-        import torch
-        return (1.0 - image,)
-
-    def to_grayscale(self, image):
-        import torch
-        # Weighted grayscale conversion
-        weights = torch.tensor([0.299, 0.587, 0.114])
-        gray = (image[..., :3] * weights).sum(dim=-1, keepdim=True)
-        gray = gray.expand_as(image[..., :3])
-        if image.shape[-1] == 4:  # Has alpha
-            gray = torch.cat([gray, image[..., 3:4]], dim=-1)
-        return (gray,)
-
-    def double_brightness(self, image):
-        import torch
-        return (torch.clamp(image * 2.0, 0.0, 1.0),)
-
-
-# ===========================================================================
-# EXAMPLE 3: Using TOML config for complex dependencies
-# ===========================================================================
-
-# For complex dependencies with custom wheel sources, use a config file:
-#
-# @isolated(env="complex-deps", config="isolation_config.toml")
-# class ComplexDepsNode:
-#     """Node with complex dependencies defined in TOML."""
-#
-#     FUNCTION = "process"
-#
-#     def process(self, image):
-#         import pytorch3d  # From custom wheel index
-#         import nvdiffrast  # From custom wheel index
-#         ...
-#
-# The isolation_config.toml would look like:
-#
-# [env]
-# name = "complex-deps"
-# python = "3.10"
-# cuda = "auto"
-#
-# [packages]
-# requirements = [
-#     "torch=={pytorch_version}",
-#     "pytorch3d==0.7.8+5043d15pt{pytorch_version}cu{cuda_short}",
-# ]
-#
-# [sources]
-# index_urls = [
-#     "https://pozzettiandrea.github.io/sam3dobjects-wheels/",
-# ]
-
-
-# ===========================================================================
-# Node registration
-# ===========================================================================
-
-NODE_CLASS_MAPPINGS = {
-    "SimpleIsolatedExample": SimpleIsolatedNode,
-    "MultiMethodIsolatedExample": MultiMethodNode,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "SimpleIsolatedExample": "Simple Isolated (Decorator Example)",
-    "MultiMethodIsolatedExample": "Multi-Method Isolated (Decorator Example)",
-}

comfy_env-0.0.18/src/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)