horde-engine 3.2.7__tar.gz → 3.2.9__tar.gz

{horde_engine-3.2.7 → horde_engine-3.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: horde-engine
-Version: 3.2.7
+Version: 3.2.9
 Summary: A wrapper around ComfyUI to allow use by AI Horde.
 Project-URL: Homepage, https://github.com/Haidra-Org/hordelib
 Project-URL: Bug Tracker, https://github.com/Haidra-Org/hordelib/issues
@@ -698,6 +698,7 @@ Requires-Dist: loguru>=0.7.3
 Requires-Dist: lpips
 Requires-Dist: matplotlib>=3.10.9
 Requires-Dist: numpy>=1.25.0
+Requires-Dist: nvidia-ml-py>=12.0.0
 Requires-Dist: omegaconf>=2.3.0
 Requires-Dist: opencv-contrib-python>=4.11.0.86
 Requires-Dist: opencv-python>=4.11.0.86
@@ -707,7 +708,6 @@ Requires-Dist: pillow
 Requires-Dist: psutil
 Requires-Dist: pydantic-settings~=2.0
 Requires-Dist: pydantic~=2.0
-Requires-Dist: pynvml>=13.0.1
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: pyyaml
 Requires-Dist: qrcode==7.4.2

{horde_engine-3.2.7 → horde_engine-3.2.9}/hordelib/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.2.7'
-__version_tuple__ = version_tuple = (3, 2, 7)
+__version__ = version = '3.2.9'
+__version_tuple__ = version_tuple = (3, 2, 9)
 
 __commit_id__ = commit_id = None

{horde_engine-3.2.7 → horde_engine-3.2.9}/hordelib/api.py

@@ -66,6 +66,7 @@ from hordelib.pipeline.payload_pp import (
     UpscalePayload,
     classify_post_processor,
 )
+from hordelib.preload import controlnet_annotators_present
 from hordelib.shared_model_manager import SharedModelManager
 from hordelib.utils.ioredirect import ComfyUIProgress, ComfyUIProgressUnit
 from hordelib.utils.logger import HordeLog
@@ -74,6 +75,7 @@ from hordelib.utils.torch_memory import (
     AcceleratorKind,
     clear_accelerator_cache,
     enumerate_accelerators,
+    get_accelerator_utilization_percent,
     get_free_ram_mb,
     get_torch_free_vram_mb,
     get_torch_total_vram_mb,
@@ -120,6 +122,7 @@ __all__ = [
     "classify_post_processor",
     "clear_accelerator_cache",
     "controlnet_annotator_download_bytes",
+    "controlnet_annotators_present",
     "enumerate_accelerators",
     "estimate_job_burden",
     "feature_available",
@@ -128,6 +131,7 @@ __all__ = [
     "get_feature_requirement",
     "get_feature_requirement_registry",
     "missing_packages",
+    "get_accelerator_utilization_percent",
     "get_free_ram_mb",
     "get_metrics_collector",
     "get_torch_free_vram_mb",

{horde_engine-3.2.7 → horde_engine-3.2.9}/hordelib/preload.py

@@ -88,12 +88,32 @@ def _pinned_annotator_ref() -> str | None:
     return None
 
 
+def _annotator_ckpts_dir() -> Path | None:
+    """Return the directory annotator checkpoints live in, or None if it cannot be determined.
+
+    ``hordelib.initialise()`` exports ``AUX_ANNOTATOR_CKPTS_PATH`` and is the authority once a run is
+    underway. When it is unset (e.g. a no-boot caller that only wants to *check* presence) the same value
+    is derived from :class:`~hordelib.settings.UserSettings`, which needs neither ComfyUI nor a GPU, so
+    presence can be read before (or without) initialisation.
+    """
+    ckpts_dir = os.environ.get("AUX_ANNOTATOR_CKPTS_PATH")
+    if ckpts_dir:
+        return Path(ckpts_dir)
+    try:
+        from hordelib.settings import UserSettings
+
+        return UserSettings.get_model_directory() / "controlnet" / "annotators"
+    except Exception as e:
+        logger.debug("Could not derive the annotator checkpoint directory: error={}", e)
+        return None
+
+
 def _preload_marker_path() -> Path | None:
     """Return the on-disk marker path, or None if the annotator directory is unknown."""
-    ckpts_dir = os.environ.get("AUX_ANNOTATOR_CKPTS_PATH")
-    if not ckpts_dir:
+    ckpts_dir = _annotator_ckpts_dir()
+    if ckpts_dir is None:
         return None
-    return Path(ckpts_dir) / _PRELOAD_MARKER_NAME
+    return ckpts_dir / _PRELOAD_MARKER_NAME
 
 
 def _annotators_already_verified(ref: str) -> bool:
@@ -107,6 +127,32 @@ def _annotators_already_verified(ref: str) -> bool:
         return False
 
 
+def controlnet_annotators_present() -> bool | None:
+    """Whether the controlnet annotators are already downloaded and verified on this machine.
+
+    Reads the on-disk preload marker (keyed to the pinned ``comfyui_controlnet_aux`` commit) exactly the
+    way :func:`download_all_controlnet_annotators` reads it for its fast-path skip, so a caller can decide
+    whether a (slow, one-time) annotator download is still pending *before* paying for it. Import-safe:
+    needs neither :func:`hordelib.initialise` nor a GPU, because the directory is derived from
+    :class:`~hordelib.settings.UserSettings` when the runtime env var is unset.
+
+    Returns:
+        ``True`` when the marker matches the pinned ref (a full set was downloaded and verified),
+        ``False`` when it is absent or stale (a download is still pending), or ``None`` when presence
+        cannot be determined (the pinned ref or the annotator directory is unknown).
+    """
+    try:
+        ref = _pinned_annotator_ref()
+        if ref is None:
+            return None
+        if _preload_marker_path() is None:
+            return None
+        return _annotators_already_verified(ref)
+    except Exception as e:  # pragma: no cover - presence is best-effort; never raise into a caller
+        logger.debug("Could not determine controlnet annotator presence: error={}", e)
+        return None
+
+
 def _record_annotators_verified(ref: str) -> None:
     """Persist that annotators for ``ref`` are downloaded and verified on this machine.
 

{horde_engine-3.2.7 → horde_engine-3.2.9}/hordelib/settings.py

@@ -5,6 +5,7 @@ from typing import Self
 
 import psutil
 from horde_model_reference import resolve_weights_root
+from loguru import logger
 
 from hordelib import is_initialised
 from hordelib.utils.switch import Switch
@@ -43,12 +44,14 @@ class UserSettings:
         if not is_initialised():
             return 0
 
-        from hordelib.utils.gpuinfo import GPUInfo
+        # Route through the backend-agnostic accelerator layer (CUDA/ROCm/XPU/MPS/CPU), not NVIDIA-only
+        # NVML, so VRAM-based mode/threshold selection is correct on non-NVIDIA cards too.
+        from hordelib.utils.torch_memory import get_torch_total_vram_mb
 
         try:
-            gpu = GPUInfo()
-            return gpu.get_total_vram_mb()
-        except Exception:
+            return get_torch_total_vram_mb()
+        except Exception as vram_error:
+            logger.debug(f"Could not read total VRAM for settings: {type(vram_error).__name__}: {vram_error}")
             return 0
 
     @staticmethod

horde_engine-3.2.9/hordelib/utils/gpuinfo.py

@@ -0,0 +1,155 @@
+"""Human-facing GPU information for diagnostics and the benchmark.
+
+VRAM totals/frees come from the backend-agnostic :mod:`hordelib.utils.torch_memory` (correct on every
+backend ComfyUI supports); NVIDIA-only enrichment (utilization, temperature, power, fan, PCIe) comes from
+:mod:`hordelib.utils.nvml`. On non-NVIDIA backends the rich stats are simply marked unsupported rather than
+erroring.
+"""
+
+from __future__ import annotations
+
+import os
+
+import torch.version
+from loguru import logger
+from pydantic import BaseModel
+from strenum import StrEnum
+
+from hordelib.utils import nvml
+from hordelib.utils.torch_memory import get_torch_free_vram_mb, get_torch_total_vram_mb
+
+_AVERAGE_SAMPLES_PER_SECOND = 10
+_AVERAGE_WINDOW_SECONDS = 60 * 5
+
+
+class GPUInfo:
+    """Collects per-device GPU statistics, keeping rolling averages of load, temperature, and power."""
+
+    def __init__(self) -> None:
+        """Initialize the collector for the device named by ``CUDA_VISIBLE_DEVICES`` (default 0)."""
+        self.avg_load: list[int] = []
+        self.avg_temp: list[int] = []
+        self.avg_power: list[int] = []
+        self._average_window_samples = _AVERAGE_SAMPLES_PER_SECOND * _AVERAGE_WINDOW_SECONDS
+        if not self.is_nvidia():
+            logger.warning("Detailed GPU info (load/temp/power) is only available on NVIDIA GPUs")
+        self.device = int(os.getenv("CUDA_VISIBLE_DEVICES", "0"))
+
+    def is_nvidia(self) -> bool:
+        """Return whether the active torch build targets NVIDIA CUDA (not ROCm/HIP)."""
+        return torch.version.cuda is not None and torch.version.hip is None
+
+    def is_amd(self) -> bool:
+        """Return whether the active torch build targets AMD ROCm/HIP."""
+        return torch.version.hip is not None
+
+    def get_total_vram_mb(self) -> int:
+        """Return the device's total VRAM in MB (backend-agnostic), or 0 when unavailable."""
+        return get_torch_total_vram_mb()
+
+    def get_free_vram_mb(self) -> int:
+        """Return the device's free VRAM in MB (backend-agnostic), or 0 when unavailable."""
+        return get_torch_free_vram_mb()
+
+    def _append_rolling(self, samples: list[int], value: int) -> list[int]:
+        """Append ``value`` to ``samples`` and trim it to the averaging window; return the trimmed list."""
+        samples.append(value)
+        return samples[-self._average_window_samples :]
+
+    def get_info(self) -> GPUInfoResult | None:
+        """Return a snapshot of this device's stats, or None when even total VRAM cannot be read.
+
+        On non-NVIDIA backends the snapshot carries backend-agnostic VRAM figures with the rich sensors
+        marked unsupported. On NVIDIA, sensors come from NVML (accurate v2 memory).
+        """
+        total_vram_mb = self.get_total_vram_mb()
+        free_vram_mb = self.get_free_vram_mb()
+
+        stats = nvml.get_device_stats(self.device) if self.is_nvidia() else None
+        if stats is None:
+            return GPUInfoResult.get_empty_info(vram_total_mb=total_vram_mb, vram_free_mb=free_vram_mb)
+
+        avg_load = self._append_rolling(self.avg_load, stats.utilization_gpu_percent)
+        avg_temp = self._append_rolling(self.avg_temp, stats.temperature_celsius)
+        avg_power = self._append_rolling(self.avg_power, stats.power_watts)
+
+        # NVML's v2 memory is more accurate than the comfy/torch totals here; prefer it when present.
+        vram_total = stats.memory.total_mb or total_vram_mb
+        vram_free = stats.memory.free_mb or free_vram_mb
+        vram_used = stats.memory.used_mb or max(vram_total - vram_free, 0)
+
+        return GPUInfoResult(
+            supported=True,
+            product=stats.name,
+            pci_gen=str(stats.pcie_link_generation),
+            pci_width=str(stats.pcie_link_width),
+            fan_speed=(str(stats.fan_speed_percent), Unit.percent),
+            vram_total=(vram_total, Unit.megabytes),
+            vram_used=(vram_used, Unit.megabytes),
+            vram_free=(vram_free, Unit.megabytes),
+            load=(stats.utilization_gpu_percent, Unit.percent),
+            temp=(stats.temperature_celsius, Unit.degrees_celsius),
+            power=(stats.power_watts, Unit.watts),
+            avg_load=(round(sum(avg_load) / len(avg_load)), Unit.percent),
+            avg_temp=(round(sum(avg_temp) / len(avg_temp)), Unit.degrees_celsius),
+            avg_power=(round(sum(avg_power) / len(avg_power)), Unit.watts),
+        )
+
+
+class Unit(StrEnum):
+    """A display unit for a GPU statistic."""
+
+    unitless = ""
+    percent = "%"
+    degrees_celsius = "C"
+    megabytes = "MiB"
+    gigabytes = "GiB"
+    watts = "W"
+
+
+class GPUInfoResult(BaseModel):
+    """Represents a single snapshot of a GPU's statistics, each value paired with its display unit."""
+
+    supported: bool
+    product: str
+    pci_gen: str
+    pci_width: str
+    fan_speed: tuple[str, Unit]
+    vram_total: tuple[int, Unit]
+    vram_used: tuple[int, Unit]
+    vram_free: tuple[int, Unit]
+    load: tuple[int, Unit]
+    temp: tuple[int, Unit]
+    power: tuple[int, Unit]
+    avg_load: tuple[int, Unit]
+    avg_temp: tuple[int, Unit]
+    avg_power: tuple[int, Unit]
+
+    def __str__(self) -> str:
+        """Return a newline-separated ``key: value unit`` rendering of every field."""
+        final_string = ""
+        for key, value in self.model_dump().items():
+            rendered_value = f"{value[0]} {value[1]}" if isinstance(value, tuple) else value
+            final_string += f"{key}: {rendered_value}\n"
+        return final_string
+
+    @classmethod
+    def get_empty_info(cls, vram_total_mb: int = 0, vram_free_mb: int = 0) -> GPUInfoResult:
+        """Create a result carrying only backend-agnostic VRAM, with the NVIDIA-only sensors zeroed."""
+        vram_used_mb = max(vram_total_mb - vram_free_mb, 0)
+        return GPUInfoResult(
+            supported=False,
+            product="unknown (detailed stats unavailable on this backend)",
+            pci_gen="?",
+            pci_width="?",
+            fan_speed=("0", Unit.percent),
+            vram_total=(vram_total_mb, Unit.megabytes),
+            vram_used=(vram_used_mb, Unit.megabytes),
+            vram_free=(vram_free_mb, Unit.megabytes),
+            load=(0, Unit.percent),
+            temp=(0, Unit.degrees_celsius),
+            power=(0, Unit.watts),
+            avg_load=(0, Unit.percent),
+            avg_temp=(0, Unit.degrees_celsius),
+            avg_power=(0, Unit.watts),
+        )

horde_engine-3.2.9/hordelib/utils/nvml.py

@@ -0,0 +1,190 @@
+"""Optional NVIDIA-only GPU telemetry via NVML, the single home for direct NVML access in hordelib.
+
+NVML is NVIDIA-specific *enrichment* (core utilization, temperature, power, and the most accurate memory
+figures); the backend-agnostic metrics that never assume NVIDIA live in
+:mod:`hordelib.utils.torch_memory`. Every function here is best-effort: when NVML is missing or the machine
+has no NVIDIA driver, each returns ``None`` so non-NVIDIA backends simply report no enrichment rather than
+erroring.
+
+Uses ``nvidia-ml-py`` (imported as ``pynvml``), the maintained official binding. Memory is read through
+``nvmlDeviceGetMemoryInfo`` with the ``nvmlMemory_v2`` version, which accounts for driver-reserved memory;
+the deprecated standalone ``pynvml`` package and its ``pynvml.smi`` interface under-report *used* VRAM
+(over-reporting *free*), which is exactly the wrong direction for a VRAM budget.
+"""
+
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING
+
+from loguru import logger
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from ctypes import c_void_p
+
+_BYTES_PER_MB = 1024 * 1024
+
+
+class NvmlMemory(BaseModel):
+    """Represents a device's NVML memory figures, in MB (from ``nvmlDeviceGetMemoryInfo`` v2)."""
+
+    total_mb: int
+    free_mb: int
+    used_mb: int
+
+
+class NvmlDeviceStats(BaseModel):
+    """Represents a single NVIDIA device's NVML telemetry snapshot (enrichment for display/diagnostics)."""
+
+    name: str
+    memory: NvmlMemory
+    utilization_gpu_percent: int
+    temperature_celsius: int
+    power_watts: int
+    fan_speed_percent: int
+    pcie_link_generation: int
+    pcie_link_width: int
+
+
+_nvml_unavailable = False
+"""Latches True after the first failed NVML init so the worker does not retry NVML every call."""
+
+
+def _nvml_module() -> object | None:
+    """Return the initialised ``nvidia-ml-py`` module, or None when NVML is unavailable.
+
+    Initialisation is attempted once; any failure (no driver, non-NVIDIA host, missing binding) latches
+    NVML off for the process and logs the reason at debug. ``nvmlInit`` is idempotent, so calling this
+    repeatedly is cheap once initialised.
+    """
+    global _nvml_unavailable
+    if _nvml_unavailable:
+        return None
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")  # silence any deprecation warning from a shim install
+            import pynvml
+        pynvml.nvmlInit()
+        return pynvml
+    except Exception as nvml_error:  # noqa: BLE001 - any NVML failure means "no NVIDIA telemetry", not a crash
+        logger.debug(f"NVML unavailable ({type(nvml_error).__name__}: {nvml_error}); NVIDIA telemetry disabled")
+        _nvml_unavailable = True
+        return None
+
+
+def is_nvml_available() -> bool:
+    """Return whether NVML telemetry can be read on this machine."""
+    return _nvml_module() is not None
+
+
+def _device_handle(pynvml: object, index: int) -> c_void_p | None:
+    """Return the NVML handle for device ``index``, or None when it cannot be resolved."""
+    try:
+        return pynvml.nvmlDeviceGetHandleByIndex(index)  # type: ignore[attr-defined]
+    except Exception as handle_error:  # noqa: BLE001 - a missing device is "no telemetry", not a crash
+        logger.debug(f"NVML handle for device {index} unavailable ({type(handle_error).__name__}: {handle_error})")
+        return None
+
+
+def get_device_memory_mb(index: int = 0) -> NvmlMemory | None:
+    """Return device ``index``'s memory (MB) via the accurate ``nvmlMemory_v2`` query, or None.
+
+    The v2 query includes driver-reserved memory in ``used``/``free``; older v1 (and the deprecated
+    ``pynvml.smi``) omit it, under-reporting used VRAM. Falls back to v1 only if the binding lacks v2.
+    """
+    pynvml = _nvml_module()
+    if pynvml is None:
+        return None
+    handle = _device_handle(pynvml, index)
+    if handle is None:
+        return None
+    try:
+        memory_v2_version = getattr(pynvml, "nvmlMemory_v2", None)
+        if memory_v2_version is not None:
+            info = pynvml.nvmlDeviceGetMemoryInfo(handle, version=memory_v2_version)  # type: ignore[attr-defined]
+        else:
+            info = pynvml.nvmlDeviceGetMemoryInfo(handle)  # type: ignore[attr-defined]
+    except Exception as memory_error:  # noqa: BLE001 - best-effort enrichment
+        logger.debug(f"NVML memory read failed for device {index} ({type(memory_error).__name__}: {memory_error})")
+        return None
+    return NvmlMemory(
+        total_mb=round(info.total / _BYTES_PER_MB),
+        free_mb=round(info.free / _BYTES_PER_MB),
+        used_mb=round(info.used / _BYTES_PER_MB),
+    )
+
+
+def get_device_utilization_percent(index: int = 0) -> int | None:
+    """Return device ``index``'s core-utilization percentage (0-100), or None when unavailable."""
+    pynvml = _nvml_module()
+    if pynvml is None:
+        return None
+    handle = _device_handle(pynvml, index)
+    if handle is None:
+        return None
+    try:
+        return int(pynvml.nvmlDeviceGetUtilizationRates(handle).gpu)  # type: ignore[attr-defined]
+    except Exception as utilization_error:  # noqa: BLE001 - best-effort enrichment
+        logger.debug(f"NVML utilization read failed for device {index} ({type(utilization_error).__name__})")
+        return None
+
+
+def _device_name(pynvml: object, handle: c_void_p) -> str:
+    """Return the device product name, decoding the bytes older bindings return."""
+    try:
+        name = pynvml.nvmlDeviceGetName(handle)  # type: ignore[attr-defined]
+    except Exception:  # noqa: BLE001 - name is cosmetic
+        return "unknown"
+    return name.decode() if isinstance(name, bytes) else str(name)
+
+
+def _best_effort_int(read: object, *, field: str, index: int) -> int:
+    """Return ``read()`` coerced to int, or 0 when the card does not support that sensor."""
+    try:
+        return int(read())  # type: ignore[operator]
+    except Exception as sensor_error:  # noqa: BLE001 - many sensors are unsupported per-card
+        logger.debug(f"NVML {field} unsupported for device {index} ({type(sensor_error).__name__})")
+        return 0
+
+
+def get_device_stats(index: int = 0) -> NvmlDeviceStats | None:
+    """Return a full NVML telemetry snapshot for device ``index``, or None when NVML is unavailable.
+
+    Memory uses the accurate v2 query; each enrichment sensor (temperature, power, fan, PCIe) is read
+    best-effort and defaults to 0 when the card does not expose it.
+    """
+    pynvml = _nvml_module()
+    if pynvml is None:
+        return None
+    handle = _device_handle(pynvml, index)
+    if handle is None:
+        return None
+    memory = get_device_memory_mb(index)
+    if memory is None:
+        return None
+
+    temperature_sensor = getattr(pynvml, "NVML_TEMPERATURE_GPU", 0)
+    power_milliwatts = _best_effort_int(lambda: pynvml.nvmlDeviceGetPowerUsage(handle), field="power", index=index)
+    return NvmlDeviceStats(
+        name=_device_name(pynvml, handle),
+        memory=memory,
+        utilization_gpu_percent=get_device_utilization_percent(index) or 0,
+        temperature_celsius=_best_effort_int(
+            lambda: pynvml.nvmlDeviceGetTemperature(handle, temperature_sensor),
+            field="temperature",
+            index=index,
+        ),
+        power_watts=round(power_milliwatts / 1000),
+        fan_speed_percent=_best_effort_int(lambda: pynvml.nvmlDeviceGetFanSpeed(handle), field="fan", index=index),
+        pcie_link_generation=_best_effort_int(
+            lambda: pynvml.nvmlDeviceGetCurrPcieLinkGeneration(handle),
+            field="pcie_gen",
+            index=index,
+        ),
+        pcie_link_width=_best_effort_int(
+            lambda: pynvml.nvmlDeviceGetCurrPcieLinkWidth(handle),
+            field="pcie_width",
+            index=index,
+        ),
+    )

{horde_engine-3.2.7 → horde_engine-3.2.9}/hordelib/utils/torch_memory.py

@@ -8,8 +8,9 @@ what the execution backend sees; otherwise they fall back to plain torch device
 cover every torch backend (CUDA/ROCm, Intel XPU, Apple MPS, CPU), not just CUDA.
 
 This module is the single source of accelerator truth for the worker: it never assumes
-NVIDIA. NVML (``pynvml``) is treated as optional NVIDIA-only enrichment elsewhere (see
-``hordelib.utils.gpuinfo``), never as a hard requirement here.
+NVIDIA. NVML is treated as optional NVIDIA-only enrichment (see :mod:`hordelib.utils.nvml`),
+never as a hard requirement here; :func:`get_accelerator_utilization_percent` is the one place
+that consults it, and only for the CUDA/NVIDIA backend.
 """
 
 from __future__ import annotations
@@ -140,6 +141,21 @@ def log_free_ram() -> None:
     logger.debug(f"Free VRAM: {get_torch_free_vram_mb():0.0f} MB, Free RAM: {get_free_ram_mb():0.0f} MB")
 
 
+def get_accelerator_utilization_percent(index: int = 0) -> int | None:
+    """Return device ``index``'s core-utilization percentage (0-100), or None when unavailable.
+
+    Utilization is vendor telemetry with no portable torch/ComfyUI equivalent, so this is best-effort and
+    backend-specific: the NVIDIA CUDA backend is read via NVML (:mod:`hordelib.utils.nvml`); every other
+    backend (ROCm, XPU, MPS, CPU) returns None until a vendor source is wired, so callers simply report no
+    GPU duty cycle there. ROCm presents through ``torch.cuda`` but is not an NVML device, so it returns None.
+    """
+    if _active_torch_kind() is not AcceleratorKind.cuda:
+        return None
+    from hordelib.utils import nvml
+
+    return nvml.get_device_utilization_percent(index)
+
+
 def _enumerate_via_comfy(mm: ModuleType) -> list[AcceleratorInfo]:
     """Enumerate devices through ComfyUI's backend-agnostic device APIs."""
     devices = mm.get_all_torch_devices()

{horde_engine-3.2.7 → horde_engine-3.2.9}/pyproject.toml

@@ -69,7 +69,7 @@ dependencies = [
     "psutil",
     "pydantic~=2.0",
     "pydantic-settings~=2.0",
-    "pynvml>=13.0.1",
+    "nvidia-ml-py>=12.0.0",
     "python-dotenv>=1.2.1",
     "pyyaml",
     "qrcode==7.4.2",