comfy-env 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

comfy_env/install.py

@@ -1,17 +1,17 @@
-"""
-Installation API for comfy-env.
-
-Example:
-    from comfy_env import install
-    install()  # Auto-discovers comfy-env.toml and installs
-"""
+"""Installation API for comfy-env."""
 
 import inspect
+import os
 from pathlib import Path
 from typing import Callable, List, Optional, Set, Union
 
-from .config.types import ComfyEnvConfig, NodeReq
-from .config.parser import load_config, discover_config
+from .config import ComfyEnvConfig, NodeDependency, load_config, discover_config, CONFIG_FILE_NAME
+
+USE_COMFY_ENV_VAR = "USE_COMFY_ENV"
+
+
+def _is_comfy_env_enabled() -> bool:
+    return os.environ.get(USE_COMFY_ENV_VAR, "1").lower() not in ("0", "false", "no", "off")
 
 
 def install(
@@ -20,27 +20,12 @@ def install(
     log_callback: Optional[Callable[[str], None]] = None,
     dry_run: bool = False,
 ) -> bool:
-    """
-    Install dependencies from comfy-env.toml.
-
-    Args:
-        config: Optional path to comfy-env.toml. Auto-discovered if not provided.
-        node_dir: Optional node directory. Auto-discovered from caller if not provided.
-        log_callback: Optional callback for logging. Defaults to print.
-        dry_run: If True, show what would be installed without installing.
-
-    Returns:
-        True if installation succeeded.
-    """
-    # Auto-discover caller's directory if not provided
+    """Install dependencies from comfy-env.toml."""
     if node_dir is None:
-        frame = inspect.stack()[1]
-        caller_file = frame.filename
-        node_dir = Path(caller_file).parent.resolve()
+        node_dir = Path(inspect.stack()[1].filename).parent.resolve()
 
     log = log_callback or print
 
-    # Load config
     if config is not None:
         config_path = Path(config)
         if not config_path.is_absolute():
@@ -50,279 +35,208 @@ def install(
         cfg = discover_config(node_dir)
 
     if cfg is None:
-        raise FileNotFoundError(
-            f"No comfy-env.toml found in {node_dir}. "
-            "Create comfy-env.toml to define dependencies."
-        )
-
-    # Install apt packages first (Linux only)
-    if cfg.apt_packages:
-        _install_apt_packages(cfg.apt_packages, log, dry_run)
-
-    # Set persistent env vars (for OpenMP settings, etc.)
-    if cfg.env_vars:
-        _set_persistent_env_vars(cfg.env_vars, log, dry_run)
-
-    # Install node dependencies
-    if cfg.node_reqs:
-        _install_node_dependencies(cfg.node_reqs, node_dir, log, dry_run)
+        raise FileNotFoundError(f"No comfy-env.toml found in {node_dir}")
 
-    # Install everything via pixi
-    _install_via_pixi(cfg, node_dir, log, dry_run)
+    if cfg.apt_packages: _install_apt_packages(cfg.apt_packages, log, dry_run)
+    if cfg.env_vars: _set_persistent_env_vars(cfg.env_vars, log, dry_run)
+    if cfg.node_reqs: _install_node_dependencies(cfg.node_reqs, node_dir, log, dry_run)
 
-    # Auto-discover and install isolated subdirectory environments
-    _install_isolated_subdirs(node_dir, log, dry_run)
+    if _is_comfy_env_enabled():
+        _install_via_pixi(cfg, node_dir, log, dry_run)
+        _install_isolated_subdirs(node_dir, log, dry_run)
+    else:
+        log("\n[comfy-env] Isolation disabled (USE_COMFY_ENV=0)")
+        _install_to_host_python(cfg, node_dir, log, dry_run)
 
     log("\nInstallation complete!")
     return True
 
 
-def _install_apt_packages(
-    packages: List[str],
-    log: Callable[[str], None],
-    dry_run: bool,
-) -> None:
-    """Install apt packages (Linux only)."""
-    import os
+def _install_apt_packages(packages: List[str], log: Callable[[str], None], dry_run: bool) -> None:
+    from .packages.apt import apt_install
     import platform
-    import shutil
-    import subprocess
-
     if platform.system() != "Linux":
-        log(f"[apt] Skipping apt packages (not Linux)")
         return
+    log(f"\n[apt] Installing: {', '.join(packages)}")
+    if not dry_run:
+        apt_install(packages, log)
 
-    log(f"\n[apt] Installing {len(packages)} system package(s):")
-    for pkg in packages:
-        log(f"  - {pkg}")
-
-    if dry_run:
-        log("  (dry run - no changes made)")
-        return
 
-    # Determine if we need sudo
-    is_root = os.geteuid() == 0
-    has_sudo = shutil.which("sudo") is not None
-    use_sudo = not is_root and has_sudo
-    prefix = ["sudo"] if use_sudo else []
+def _set_persistent_env_vars(env_vars: dict, log: Callable[[str], None], dry_run: bool) -> None:
+    import platform, subprocess
+    if not env_vars: return
 
-    if not is_root and not has_sudo:
-        log(f"[apt] Warning: No root access. Install manually:")
-        log(f"  sudo apt-get update && sudo apt-get install -y {' '.join(packages)}")
-        return
-
-    # Run apt-get update (suppress output, just show errors)
-    log("[apt] Updating package lists...")
-    result = subprocess.run(
-        prefix + ["apt-get", "update"],
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode != 0:
-        log(f"[apt] Warning: apt-get update failed: {result.stderr.strip()}")
-
-    # Install each package individually (some may not exist on all distros)
-    log("[apt] Installing packages...")
-    installed = []
-    skipped = []
-    for pkg in packages:
-        result = subprocess.run(
-            prefix + ["apt-get", "install", "-y", pkg],
-            capture_output=True,
-            text=True,
-        )
-        if result.returncode == 0:
-            installed.append(pkg)
-            log(f"  [apt] Installed {pkg}")
-        else:
-            skipped.append(pkg)
-            log(f"  [apt] Skipped {pkg} (not available)")
-
-    if installed:
-        log(f"[apt] Installed {len(installed)} package(s)")
-    if skipped:
-        log(f"[apt] Skipped {len(skipped)} unavailable package(s)")
-
-
-def _set_persistent_env_vars(
-    env_vars: dict,
-    log: Callable[[str], None],
-    dry_run: bool,
-) -> None:
-    """Set env vars permanently (survives restarts)."""
-    import os
-    import platform
-    import subprocess
-    from pathlib import Path
-
-    if not env_vars:
-        return
+    log(f"\n[env] Setting {len(env_vars)} env var(s)")
+    for k, v in env_vars.items(): log(f"  {k}={v}")
+    if dry_run: return
 
     system = platform.system()
-    log(f"\n[env] Setting {len(env_vars)} persistent environment variable(s)...")
-
-    for key, value in env_vars.items():
-        log(f"  - {key}={value}")
-
-    if dry_run:
-        log("  (dry run - no changes made)")
-        return
-
     if system == "Windows":
-        # Windows: use setx (writes to registry)
-        for key, value in env_vars.items():
-            result = subprocess.run(
-                ["setx", key, value],
-                capture_output=True, text=True
-            )
-            if result.returncode == 0:
-                log(f"  [env] Set {key} (Windows registry)")
-            else:
-                log(f"  [env] Warning: Failed to set {key}: {result.stderr.strip()}")
-        log("[env] Restart terminal/ComfyUI for changes to take effect")
-
-    elif system == "Darwin":  # macOS
-        # macOS: launchctl for GUI apps + zshrc for terminal
-        for key, value in env_vars.items():
-            subprocess.run(["launchctl", "setenv", key, value], capture_output=True)
-            log(f"  [env] Set {key} (launchctl)")
-
-        # Also add to zshrc for terminal (zsh is default on macOS)
+        for k, v in env_vars.items():
+            subprocess.run(["setx", k, v], capture_output=True)
+    elif system == "Darwin":
+        for k, v in env_vars.items():
+            subprocess.run(["launchctl", "setenv", k, v], capture_output=True)
         _add_to_shell_profile(env_vars, log)
-
-    else:  # Linux
+    else:
         _add_to_shell_profile(env_vars, log)
 
 
-def _add_to_shell_profile(
-    env_vars: dict,
-    log: Callable[[str], None],
-) -> None:
-    """Add env vars to shell profile (Linux/macOS)."""
-    import os
-    from pathlib import Path
-
-    # Determine shell profile
+def _add_to_shell_profile(env_vars: dict, log: Callable[[str], None]) -> None:
     shell = os.environ.get("SHELL", "/bin/bash")
-    if "zsh" in shell:
-        rc_file = Path.home() / ".zshrc"
-    else:
-        rc_file = Path.home() / ".bashrc"
-
+    rc_file = Path.home() / (".zshrc" if "zsh" in shell else ".bashrc")
     profile_file = Path.home() / ".comfy-env-profile"
 
-    # Write env vars to our dedicated file
     with open(profile_file, "w") as f:
-        f.write("# Generated by comfy-env - do not edit manually\n")
-        for key, value in env_vars.items():
-            f.write(f'export {key}="{value}"\n')
-    log(f"  [env] Wrote {profile_file}")
+        f.write("# Generated by comfy-env\n")
+        for k, v in env_vars.items():
+            f.write(f'export {k}="{v}"\n')
 
-    # Add source line to shell rc (only once)
     source_line = f'source "{profile_file}"'
     existing = rc_file.read_text() if rc_file.exists() else ""
-
-    if source_line not in existing and str(profile_file) not in existing:
+    if source_line not in existing:
         with open(rc_file, "a") as f:
-            f.write(f'\n# comfy-env environment variables\n')
-            f.write(f'{source_line}\n')
-        log(f"  [env] Added source line to {rc_file}")
-    else:
-        log(f"  [env] Already configured in {rc_file}")
-
-    log("[env] Restart terminal/ComfyUI for changes to take effect")
-
+            f.write(f'\n# comfy-env\n{source_line}\n')
+    log(f"  [env] Wrote {profile_file}")
 
-def _install_node_dependencies(
-    node_reqs: List[NodeReq],
-    node_dir: Path,
-    log: Callable[[str], None],
-    dry_run: bool,
-) -> None:
-    """Install node dependencies (other ComfyUI custom nodes)."""
-    from .nodes import install_node_deps
 
+def _install_node_dependencies(node_reqs: List[NodeDependency], node_dir: Path, log: Callable[[str], None], dry_run: bool) -> None:
+    from .packages.node_dependencies import install_node_dependencies
     custom_nodes_dir = node_dir.parent
     log(f"\nInstalling {len(node_reqs)} node dependencies...")
-
     if dry_run:
         for req in node_reqs:
-            node_path = custom_nodes_dir / req.name
-            status = "exists" if node_path.exists() else "would clone"
-            log(f"  {req.name}: {status}")
+            log(f"  {req.name}: {'exists' if (custom_nodes_dir / req.name).exists() else 'would clone'}")
         return
+    install_node_dependencies(node_reqs, custom_nodes_dir, log, {node_dir.name})
 
-    visited: Set[str] = {node_dir.name}
-    install_node_deps(node_reqs, custom_nodes_dir, log, visited)
 
+def _install_via_pixi(cfg: ComfyEnvConfig, node_dir: Path, log: Callable[[str], None], dry_run: bool) -> None:
+    from .packages.pixi import ensure_pixi, get_pixi_python, pixi_clean
+    from .packages.toml_generator import write_pixi_toml
+    from .packages.cuda_wheels import get_wheel_url, CUDA_TORCH_MAP
+    from .detection import get_recommended_cuda_version
+    from .environment.cache import get_central_env_path, write_marker, write_env_metadata, MARKER_FILE, get_cache_dir
+    import shutil, subprocess, sys
 
-def _install_via_pixi(
-    cfg: ComfyEnvConfig,
-    node_dir: Path,
-    log: Callable[[str], None],
-    dry_run: bool,
-) -> None:
-    """Install all packages via pixi."""
-    from .pixi import pixi_install
-
-    # Count what we're installing
-    cuda_count = len(cfg.cuda_packages)
-
-    # Count from passthrough (pixi-native format)
     deps = cfg.pixi_passthrough.get("dependencies", {})
     pypi_deps = cfg.pixi_passthrough.get("pypi-dependencies", {})
-
-    if cuda_count == 0 and not deps and not pypi_deps:
+    if not cfg.cuda_packages and not deps and not pypi_deps:
         log("No packages to install")
         return
 
     log(f"\nInstalling via pixi:")
-    if cuda_count:
-        log(f"  CUDA packages: {', '.join(cfg.cuda_packages)}")
-    if deps:
-        log(f"  Conda packages: {len(deps)}")
-    if pypi_deps:
-        log(f"  PyPI packages: {len(pypi_deps)}")
+    if cfg.cuda_packages: log(f"  CUDA: {', '.join(cfg.cuda_packages)}")
+    if deps: log(f"  Conda: {len(deps)}")
+    if pypi_deps: log(f"  PyPI: {len(pypi_deps)}")
+    if dry_run: return
+
+    pixi_clean(node_dir, log)
+    (node_dir / ".pixi").mkdir(parents=True, exist_ok=True)
+    (node_dir / ".pixi" / "config.toml").write_text("detached-environments = false\n")
+
+    pixi_path = ensure_pixi(log=log)
+    cuda_version = torch_version = None
+    if cfg.has_cuda and sys.platform != "darwin":
+        cuda_version = get_recommended_cuda_version()
+        if cuda_version:
+            torch_version = CUDA_TORCH_MAP.get(".".join(cuda_version.split(".")[:2]), "2.8")
+
+    write_pixi_toml(cfg, node_dir, log)
+    log("Running pixi install...")
+    result = subprocess.run([str(pixi_path), "install"], cwd=node_dir, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"pixi install failed: {result.stderr}")
+
+    if cfg.cuda_packages and cuda_version:
+        log(f"Installing CUDA packages...")
+        python_path = get_pixi_python(node_dir)
+        if not python_path:
+            raise RuntimeError("No Python in pixi env")
+
+        result = subprocess.run([str(python_path), "-c", "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"],
+                               capture_output=True, text=True)
+        py_version = result.stdout.strip() if result.returncode == 0 else f"{sys.version_info.major}.{sys.version_info.minor}"
+
+        for package in cfg.cuda_packages:
+            wheel_url = get_wheel_url(package, torch_version, cuda_version, py_version)
+            if not wheel_url:
+                raise RuntimeError(f"No wheel for {package}")
+            log(f"  {package}")
+            result = subprocess.run([str(python_path), "-m", "pip", "install", "--no-deps", "--no-cache-dir", wheel_url],
+                                   capture_output=True, text=True)
+            if result.returncode != 0:
+                raise RuntimeError(f"Failed: {result.stderr}")
+
+    old_env = node_dir / ".pixi" / "envs" / "default"
+    config_path = node_dir / "comfy-env.toml"
+    main_node_dir = node_dir
+    for parent in node_dir.parents:
+        if parent.parent.name == "custom_nodes":
+            main_node_dir = parent
+            break
+
+    central_env = get_central_env_path(main_node_dir, config_path)
+    if old_env.exists():
+        get_cache_dir()
+        if central_env.exists(): shutil.rmtree(central_env)
+        shutil.move(str(old_env), str(central_env))
+        write_marker(config_path, central_env)
+        write_env_metadata(central_env, config_path.parent / MARKER_FILE)
+        shutil.rmtree(node_dir / ".pixi", ignore_errors=True)
+        log(f"Env: {central_env}")
+
+
+def _install_to_host_python(cfg: ComfyEnvConfig, node_dir: Path, log: Callable[[str], None], dry_run: bool) -> None:
+    import shutil, subprocess, sys
+    from .packages.cuda_wheels import get_wheel_url, CUDA_TORCH_MAP
+    from .detection import get_recommended_cuda_version
 
-    if dry_run:
-        log("\n(dry run - no changes made)")
+    pypi_deps = cfg.pixi_passthrough.get("pypi-dependencies", {})
+    if not pypi_deps and not cfg.cuda_packages:
+        log("No packages to install")
         return
 
-    pixi_install(cfg, node_dir, log)
-
-
-def _install_isolated_subdirs(
-    node_dir: Path,
-    log: Callable[[str], None],
-    dry_run: bool,
-) -> None:
-    """Find and install comfy-env.toml in subdirectories."""
-    from .pixi import pixi_install
-    from .config.parser import CONFIG_FILE_NAME
-
-    # Find all comfy-env.toml files in subdirectories (not root)
+    pip_packages = []
+    for pkg, spec in pypi_deps.items():
+        if isinstance(spec, str):
+            pip_packages.append(pkg if spec == "*" else f"{pkg}{spec}")
+        elif isinstance(spec, dict):
+            extras = spec.get("extras", [])
+            version = spec.get("version", "*")
+            name = f"{pkg}[{','.join(extras)}]" if extras else pkg
+            pip_packages.append(name if version == "*" else f"{name}{version}")
+
+    log(f"\nInstalling to {sys.executable}")
+    if dry_run: return
+
+    use_uv = shutil.which("uv")
+    if pip_packages:
+        cmd = ["uv", "pip", "install", "--python", sys.executable] + pip_packages if use_uv else [sys.executable, "-m", "pip", "install"] + pip_packages
+        subprocess.run(cmd, capture_output=True)
+
+    if cfg.cuda_packages:
+        cuda_version = get_recommended_cuda_version()
+        if not cuda_version: return
+        torch_version = CUDA_TORCH_MAP.get(".".join(cuda_version.split(".")[:2]), "2.8")
+        py_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+
+        for package in cfg.cuda_packages:
+            wheel_url = get_wheel_url(package, torch_version, cuda_version, py_version)
+            if wheel_url:
+                cmd = ["uv", "pip", "install", "--python", sys.executable, "--no-deps", wheel_url] if use_uv else [sys.executable, "-m", "pip", "install", "--no-deps", wheel_url]
+                subprocess.run(cmd, capture_output=True)
+
+
+def _install_isolated_subdirs(node_dir: Path, log: Callable[[str], None], dry_run: bool) -> None:
     for config_file in node_dir.rglob(CONFIG_FILE_NAME):
-        if config_file.parent == node_dir:
-            continue  # Skip root (already installed)
-
-        sub_dir = config_file.parent
-        relative = sub_dir.relative_to(node_dir)
-
-        log(f"\n[isolated] Installing: {relative}")
-        sub_cfg = load_config(config_file)
+        if config_file.parent == node_dir: continue
+        log(f"\n[isolated] {config_file.parent.relative_to(node_dir)}")
+        if not dry_run:
+            _install_via_pixi(load_config(config_file), config_file.parent, log, dry_run)
 
-        if dry_run:
-            log(f"  (dry run)")
-            continue
 
-        pixi_install(sub_cfg, sub_dir, log)
-
-
-def verify_installation(
-    packages: List[str],
-    log: Callable[[str], None] = print,
-) -> bool:
-    """Verify that packages are importable."""
+def verify_installation(packages: List[str], log: Callable[[str], None] = print) -> bool:
     all_ok = True
     for package in packages:
         import_name = package.replace("-", "_").split("[")[0]

comfy_env/isolation/__init__.py

@@ -1,9 +1,40 @@
 """
-Isolation module for wrapping ComfyUI nodes to run in isolated environments.
+Isolation layer - Process isolation for node execution.
+
+Wraps node classes to execute in isolated subprocess environments.
 """
 
-from .wrap import wrap_isolated_nodes
+from .wrap import (
+    wrap_isolated_nodes,
+    wrap_nodes,
+)
+from .workers import (
+    Worker,
+    WorkerError,
+    MPWorker,
+    SubprocessWorker,
+)
+from .tensor_utils import (
+    TensorKeeper,
+    keep_tensor,
+    keep_tensors_recursive,
+    prepare_tensor_for_ipc,
+    prepare_for_ipc_recursive,
+)
 
 __all__ = [
+    # Node wrapping
     "wrap_isolated_nodes",
+    "wrap_nodes",
+    # Workers
+    "Worker",
+    "WorkerError",
+    "MPWorker",
+    "SubprocessWorker",
+    # Tensor utilities
+    "TensorKeeper",
+    "keep_tensor",
+    "keep_tensors_recursive",
+    "prepare_tensor_for_ipc",
+    "prepare_for_ipc_recursive",
 ]

comfy_env/isolation/tensor_utils.py

@@ -0,0 +1,83 @@
+"""Tensor utilities for IPC - prevents GC races and handles CUDA re-share."""
+
+import collections
+import logging
+import threading
+import time
+from typing import Any
+
+logger = logging.getLogger("comfy_env")
+
+
+class TensorKeeper:
+    """Keep tensor references during IPC to prevent premature GC."""
+
+    def __init__(self, retention_seconds: float = 30.0):
+        self.retention_seconds = retention_seconds
+        self._keeper: collections.deque = collections.deque()
+        self._lock = threading.Lock()
+
+    def keep(self, t: Any) -> None:
+        try:
+            import torch
+            if not isinstance(t, torch.Tensor): return
+        except ImportError: return
+
+        now = time.time()
+        with self._lock:
+            self._keeper.append((now, t))
+            while self._keeper and now - self._keeper[0][0] > self.retention_seconds:
+                self._keeper.popleft()
+
+    def keep_recursive(self, obj: Any) -> None:
+        try:
+            import torch
+            if isinstance(obj, torch.Tensor): self.keep(obj)
+            elif isinstance(obj, (list, tuple)):
+                for item in obj: self.keep_recursive(item)
+            elif isinstance(obj, dict):
+                for v in obj.values(): self.keep_recursive(v)
+        except ImportError: pass
+
+    def __len__(self) -> int:
+        with self._lock: return len(self._keeper)
+
+
+_tensor_keeper = TensorKeeper()
+keep_tensor = lambda t: _tensor_keeper.keep(t)
+keep_tensors_recursive = lambda obj: _tensor_keeper.keep_recursive(obj)
+
+
+def prepare_tensor_for_ipc(t: Any) -> Any:
+    """Clone tensor if it was received via IPC (can't be re-shared)."""
+    try:
+        import torch
+        if not isinstance(t, torch.Tensor) or not t.is_cuda: return t
+
+        import torch.multiprocessing.reductions as reductions
+        try:
+            reductions.reduce_tensor(t)
+            return t
+        except RuntimeError as e:
+            if "received from another process" in str(e):
+                size_mb = t.numel() * t.element_size() / (1024 * 1024)
+                if size_mb > 100:
+                    logger.warning(f"Cloning large CUDA tensor ({size_mb:.1f}MB) for IPC")
+                return t.clone()
+            raise
+    except ImportError: return t
+
+
+def prepare_for_ipc_recursive(obj: Any) -> Any:
+    """Recursively prepare tensors for IPC and keep references."""
+    try:
+        import torch
+        if isinstance(obj, torch.Tensor):
+            prepared = prepare_tensor_for_ipc(obj)
+            keep_tensor(prepared)
+            return prepared
+        elif isinstance(obj, list): return [prepare_for_ipc_recursive(x) for x in obj]
+        elif isinstance(obj, tuple): return tuple(prepare_for_ipc_recursive(x) for x in obj)
+        elif isinstance(obj, dict): return {k: prepare_for_ipc_recursive(v) for k, v in obj.items()}
+    except ImportError: pass
+    return obj

comfy_env/isolation/workers/__init__.py

@@ -0,0 +1,16 @@
+"""
+Workers - Process isolation implementations.
+
+Provides multiprocessing and subprocess-based workers for isolated execution.
+"""
+
+from .base import Worker, WorkerError
+from .mp import MPWorker
+from .subprocess import SubprocessWorker
+
+__all__ = [
+    "Worker",
+    "WorkerError",
+    "MPWorker",
+    "SubprocessWorker",
+]

comfy_env/{workers → isolation/workers}/mp.py

@@ -29,7 +29,7 @@ from queue import Empty as QueueEmpty
 from typing import Any, Callable, Optional
 
 from .base import Worker, WorkerError
-from .tensor_utils import prepare_for_ipc_recursive, keep_tensors_recursive
+from ..tensor_utils import prepare_for_ipc_recursive, keep_tensors_recursive
 
 logger = logging.getLogger("comfy_env")
 

comfy_env/{workers → isolation/workers}/subprocess.py

@@ -42,7 +42,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from .base import Worker, WorkerError
-from ..pixi import get_pixi_path
+from ...packages.pixi import get_pixi_path
 
 # Debug logging (set COMFY_ENV_DEBUG=1 to enable)
 _DEBUG = os.environ.get("COMFY_ENV_DEBUG", "").lower() in ("1", "true", "yes")
@@ -440,7 +440,7 @@ def _watchdog():
             f.flush()
 
         # Also print
-        print(f"\\n=== WATCHDOG TICK {tick} ===", flush=True)
+        print(f"\\n=== WATCHDOG TICK {tick} (debug only, don't worry) ===", flush=True)
         print(dump, flush=True)
         print("=== END ===\\n", flush=True)