horde-engine 3.1.2__tar.gz → 3.2.2__tar.gz

{horde_engine-3.1.2 → horde_engine-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: horde-engine
-Version: 3.1.2
+Version: 3.2.2
 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
@@ -679,17 +679,15 @@ Requires-Dist: aiohttp>=3.11.8
 Requires-Dist: alembic
 Requires-Dist: av>=16.0.0
 Requires-Dist: blake3
-Requires-Dist: clip-anytorch>=2.6.0
 Requires-Dist: comfy-aimdo==0.4.9
 Requires-Dist: comfy-kitchen==0.2.10
 Requires-Dist: comfyui-embedded-docs==0.5.3
 Requires-Dist: comfyui-frontend-package==1.45.15
 Requires-Dist: comfyui-workflow-templates==0.9.98
-Requires-Dist: diffusers>=0.25.0
 Requires-Dist: distro>=1.9.0
 Requires-Dist: einops
-Requires-Dist: fairscale>=0.4.13
 Requires-Dist: filelock
+Requires-Dist: ftfy
 Requires-Dist: fuzzywuzzy>=0.18.0
 Requires-Dist: gitpython>=3.1.45
 Requires-Dist: horde-model-reference<6.0.0,>=5.1.1
@@ -697,11 +695,9 @@ Requires-Dist: horde-sdk>=0.20.1
 Requires-Dist: kornia>=0.7.1
 Requires-Dist: logfire[system-metrics]==4.14.2
 Requires-Dist: loguru>=0.7.3
-Requires-Dist: lpips>=0.1.4
 Requires-Dist: matplotlib>=3.10.9
 Requires-Dist: numpy>=1.25.0
 Requires-Dist: omegaconf>=2.3.0
-Requires-Dist: open-clip-torch>=2.32.0
 Requires-Dist: opencv-contrib-python>=4.11.0.86
 Requires-Dist: opencv-python>=4.11.0.86
 Requires-Dist: opentelemetry-instrumentation-aiohttp-client>=0.59b0
@@ -712,22 +708,17 @@ 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: pytorch-lightning>=2.5.6
 Requires-Dist: pyyaml
 Requires-Dist: qrcode==7.4.2
-Requires-Dist: rembg[cpu]>=2.0.67
 Requires-Dist: requests
 Requires-Dist: safetensors>=0.4.2
 Requires-Dist: scikit-image>=0.25.2
 Requires-Dist: scipy
 Requires-Dist: sentencepiece
 Requires-Dist: simpleeval>=1.0.0
-Requires-Dist: soundfile>=0.13.1
-Requires-Dist: spandrel-extra-arches>=0.2.0
 Requires-Dist: spandrel>=0.4.1
 Requires-Dist: sqlalchemy>=2.0.0
 Requires-Dist: strenum>=0.4.15
-Requires-Dist: timm==0.9.16
 Requires-Dist: tokenizers>=0.13.3
 Requires-Dist: torchdiffeq>=0.2.5
 Requires-Dist: torchsde
@@ -738,6 +729,14 @@ Requires-Dist: typing-extensions>=4.15.0
 Requires-Dist: unidecode>=1.4.0
 Requires-Dist: yapf>=0.43.0
 Requires-Dist: yarl>=1.18.0
+Provides-Extra: controlnet
+Requires-Dist: albumentations; extra == 'controlnet'
+Requires-Dist: fvcore; extra == 'controlnet'
+Requires-Dist: mediapipe>=0.10; extra == 'controlnet'
+Requires-Dist: onnxruntime>=1.16; extra == 'controlnet'
+Requires-Dist: scikit-learn; extra == 'controlnet'
+Requires-Dist: trimesh[easy]; extra == 'controlnet'
+Requires-Dist: yacs; extra == 'controlnet'
 Provides-Extra: cpu
 Requires-Dist: torch; extra == 'cpu'
 Requires-Dist: torchvision; extra == 'cpu'
@@ -750,6 +749,12 @@ Requires-Dist: torchvision; extra == 'cu130'
 Provides-Extra: cu132
 Requires-Dist: torch; extra == 'cu132'
 Requires-Dist: torchvision; extra == 'cu132'
+Provides-Extra: layerdiffuse
+Requires-Dist: diffusers>=0.25.0; extra == 'layerdiffuse'
+Provides-Extra: rembg
+Requires-Dist: rembg[cpu]>=2.0.67; extra == 'rembg'
+Provides-Extra: upscale-extra
+Requires-Dist: spandrel-extra-arches>=0.2.0; extra == 'upscale-extra'
 Description-Content-Type: text/markdown
 
 # horde-engine

{horde_engine-3.1.2 → horde_engine-3.2.2}/hordelib/_version.py

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

{horde_engine-3.1.2 → horde_engine-3.2.2}/hordelib/api.py

@@ -31,6 +31,14 @@ from hordelib.feature_impact import (
     get_baseline_burden,
     get_feature_impact_registry,
 )
+from hordelib.feature_requirements import (
+    FeatureRequirement,
+    available_features,
+    feature_available,
+    get_feature_requirement,
+    get_feature_requirement_registry,
+    missing_packages,
+)
 from hordelib.horde import (
     HordeLib,
     ProgressReport,
@@ -58,6 +66,10 @@ from hordelib.shared_model_manager import SharedModelManager
 from hordelib.utils.ioredirect import ComfyUIProgress, ComfyUIProgressUnit
 from hordelib.utils.logger import HordeLog
 from hordelib.utils.torch_memory import (
+    AcceleratorInfo,
+    AcceleratorKind,
+    clear_accelerator_cache,
+    enumerate_accelerators,
     get_free_ram_mb,
     get_torch_free_vram_mb,
     get_torch_total_vram_mb,
@@ -66,6 +78,8 @@ from hordelib.utils.torch_memory import (
 
 __all__ = [
     "FEATURE_KIND",
+    "AcceleratorInfo",
+    "AcceleratorKind",
     "BaselineBurden",
     "BurdenEstimate",
     "CalibrationSample",
@@ -75,6 +89,7 @@ __all__ = [
     "DownloadTrigger",
     "FeatureImpact",
     "FeatureImpactRegistry",
+    "FeatureRequirement",
     "ExecutionBackend",
     "FacefixPayload",
     "HordeLib",
@@ -96,10 +111,17 @@ __all__ = [
     "StripBackgroundPayload",
     "UpscalePayload",
     "VRAMStats",
+    "available_features",
     "classify_post_processor",
+    "clear_accelerator_cache",
+    "enumerate_accelerators",
     "estimate_job_burden",
+    "feature_available",
     "get_baseline_burden",
     "get_feature_impact_registry",
+    "get_feature_requirement",
+    "get_feature_requirement_registry",
+    "missing_packages",
     "get_free_ram_mb",
     "get_metrics_collector",
     "get_torch_free_vram_mb",

{horde_engine-3.1.2 → horde_engine-3.2.2}/hordelib/comfy_horde.py

@@ -32,6 +32,7 @@ from hordelib.utils.ioredirect import ComfyUIProgress, OutputCollector
 from hordelib.config_path import get_hordelib_path
 from hordelib.execution import comfy_patches
 from hordelib.execution.graph_utils import GraphDict
+from hordelib.utils.torch_memory import clear_accelerator_cache
 
 # Note It may not be abundantly clear with no context what is going on below, and I will attempt to clarify:
 #
@@ -374,11 +375,9 @@ def do_comfy_import(
 
 
 def clear_gc_and_torch_cache() -> None:
-    """Clear the garbage collector and the PyTorch cache."""
+    """Clear the garbage collector and the active backend's device cache."""
     gc.collect()
-    from torch.cuda import empty_cache
-
-    empty_cache()
+    clear_accelerator_cache()
 
 
 def pin_models_in_vram() -> bool:
@@ -1079,7 +1078,7 @@ class Comfy_Horde:
             _mc.record_phase("pipeline_validate", _validate_seconds)
             _mc.record_phase("pipeline_execute", _execute_seconds)
             _mc.record_phase("pipeline_finalize", time.perf_counter() - _t_post_execute)
-        except Exception:  # noqa: BLE001 - instrumentation must never break a run
+        except Exception:
             pass
 
         # Record pipeline duration

horde_engine-3.2.2/hordelib/feature_requirements.py

@@ -0,0 +1,115 @@
+"""Which optional features are actually installable in this environment.
+
+Some hordelib features depend on heavy, platform-constrained native packages that are not
+part of the lean base install (they have no wheels for some accelerators, e.g. Intel XPU /
+Apple MPS / Ascend, so forcing them into base would block a base install there). Those
+packages live in ``horde-engine`` feature extras (see ``[project.optional-dependencies]``)
+and the feature's call site guards its import via :mod:`hordelib.utils.optional_deps`.
+
+This module is the single, typed source of truth mapping each such feature to the extra and
+the import-names that back it, plus a runtime probe (:func:`feature_available`) so a consumer
+(notably the worker) can decide what to advertise *before* a job arrives rather than failing
+mid-job. It is the one place to edit when ComfyUI's (or a node's) backend support changes.
+
+Features with no entry here have no optional dependency and are always considered available
+(core inference, the safety classifier, ESRGAN upscalers and the CodeFormer/GFPGAN face
+fixers are all pure PyTorch and run on every backend). Detection only: this module never
+installs anything; extras are resolved at lock/sync time by the packaging tool.
+
+This module is comfy-free and import-safe before ``hordelib.initialise()``; it is part of the
+public API surface re-exported from :mod:`hordelib.api`.
+"""
+
+import importlib.util
+
+from pydantic import BaseModel
+
+from hordelib.feature_impact import FEATURE_KIND
+
+__all__ = [
+    "FeatureRequirement",
+    "available_features",
+    "feature_available",
+    "get_feature_requirement",
+    "get_feature_requirement_registry",
+    "missing_packages",
+]
+
+
+class FeatureRequirement(BaseModel):
+    """The optional packages one feature needs, and the extra that provides them."""
+
+    feature: FEATURE_KIND
+    packages: tuple[str, ...]
+    """Top-level import names that must ALL be importable for the feature to be available."""
+    extra: str
+    """The ``horde-engine`` extra that installs ``packages`` (e.g. ``rembg`` -> ``[rembg]``)."""
+    label: str
+    """Human-readable feature name, used in "install this extra" messages."""
+
+
+# Only the backend-constrained features appear here. controlnet gates on onnxruntime alone: of the
+# preprocessors hordelib exposes as horde control_types (CONTROLNET_IMAGE_PREPROCESSOR_MAP), only
+# Openpose (DWPose) needs a blocker dep, and that dep is onnxruntime. mediapipe backs only
+# mediapipe_face / mesh_graphormer, which are not horde control_types, so it is shipped in the
+# `controlnet` extra for node parity but is not required to serve controlnet jobs.
+_REQUIREMENT_SEEDS: list[FeatureRequirement] = [
+    FeatureRequirement(
+        feature=FEATURE_KIND.strip_background,
+        packages=("rembg",),
+        extra="rembg",
+        label="strip_background (background removal)",
+    ),
+    FeatureRequirement(
+        feature=FEATURE_KIND.controlnet,
+        packages=("onnxruntime",),
+        extra="controlnet",
+        label="controlnet preprocessing (annotators)",
+    ),
+]
+
+_REGISTRY: dict[FEATURE_KIND, FeatureRequirement] = {req.feature: req for req in _REQUIREMENT_SEEDS}
+
+
+def _is_importable(package: str) -> bool:
+    """Return whether *package* can be found in the environment, never raising.
+
+    ``find_spec`` can raise (e.g. ``ModuleNotFoundError`` for a missing parent, or ``ValueError``)
+    rather than returning ``None``; for a capability probe any failure means "not available".
+    """
+    try:
+        return importlib.util.find_spec(package) is not None
+    except (ImportError, ValueError):
+        return False
+
+
+def get_feature_requirement_registry() -> dict[FEATURE_KIND, FeatureRequirement]:
+    """Return the mapping of features to their optional-dependency requirements."""
+    return _REGISTRY
+
+
+def get_feature_requirement(feature: FEATURE_KIND) -> FeatureRequirement | None:
+    """Return the requirement for *feature*, or None when it has no optional dependency."""
+    return _REGISTRY.get(feature)
+
+
+def missing_packages(feature: FEATURE_KIND) -> tuple[str, ...]:
+    """Return the requirement's packages that are not importable (empty when all present)."""
+    requirement = _REGISTRY.get(feature)
+    if requirement is None:
+        return ()
+    return tuple(package for package in requirement.packages if not _is_importable(package))
+
+
+def feature_available(feature: FEATURE_KIND) -> bool:
+    """Return whether *feature* can run here.
+
+    A feature with no requirement entry is always available; otherwise every package its
+    requirement names must be importable.
+    """
+    return not missing_packages(feature)
+
+
+def available_features() -> set[FEATURE_KIND]:
+    """Return the set of features runnable in this environment (always-available ones included)."""
+    return {feature for feature in FEATURE_KIND if feature_available(feature)}

{horde_engine-3.1.2 → horde_engine-3.2.2}/hordelib/installation/installer.py

@@ -24,16 +24,24 @@ def _run_git(args: list[str], cwd: Path) -> str:
     """Run a git command, returning stripped stdout.
 
     Raises:
-        GitCommandError: If git exits non-zero.
+        GitCommandError: If git is not installed/on PATH, or exits non-zero.
     """
-    result = subprocess.run(
-        ["git", *args],
-        cwd=str(cwd),
-        text=True,
-        capture_output=True,
-        encoding="utf-8",
-        errors="replace",
-    )
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            cwd=str(cwd),
+            text=True,
+            capture_output=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+    except FileNotFoundError as exc:
+        # A bare-name "git" that the OS cannot find raises FileNotFoundError, not a non-zero exit. Turn it
+        # into the same actionable error all callers already handle, naming why git is needed.
+        raise GitCommandError(
+            "git was not found on PATH. hordelib needs git to fetch and pin ComfyUI and its custom nodes; "
+            "install git (https://git-scm.com/downloads) and make sure it is on PATH, then retry.",
+        ) from exc
     if result.returncode != 0:
         raise GitCommandError(f"git {' '.join(args)} failed in {cwd}: {result.stderr.strip()}")
     return result.stdout.strip()

{horde_engine-3.1.2 → horde_engine-3.2.2}/hordelib/nodes/facerestore_cf/__init__.py

@@ -175,7 +175,8 @@ class FaceRestoreCFWithModel:
                         output = facerestore_model(cropped_face_t, w=codeformer_fidelity)[0]
                         restored_face = tensor2img(output, rgb2bgr=True, min_max=(-1, 1))
                     del output
-                    torch.cuda.empty_cache()
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
                 except Exception as error:
                     print(f"\tFailed inference for CodeFormer: {error}", file=sys.stderr)
                     restored_face = tensor2img(cropped_face_t, rgb2bgr=True, min_max=(-1, 1))

{horde_engine-3.1.2 → horde_engine-3.2.2}/hordelib/nodes/facerestore_cf/basicsr/utils/realesrgan_utils.py

@@ -221,7 +221,8 @@ class RealESRGANer:
                 if img_mode == "L":
                     output_img = cv2.cvtColor(output_img, cv2.COLOR_BGR2GRAY)
             del output_img_t
-            torch.cuda.empty_cache()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
         except RuntimeError as error:
             output_img = cv2.resize(
                 self.img_pre_pad,

{horde_engine-3.1.2 → horde_engine-3.2.2}/hordelib/preload.py

@@ -45,6 +45,12 @@ _ANNOTATOR_NODE_NAME = "comfyui_controlnet_aux"
 # pinned annotator commit so later processes can skip it. See module docstring.
 _PRELOAD_MARKER_NAME = ".hordelib_preload_complete"
 
+# comfyui_controlnet_aux preprocessors that cannot import without an optional `controlnet`-extra
+# package, so they must be dropped from the preload on a lean base install (their node_wrapper is
+# guarded and simply does not register). Openpose's DWPose detector is the only horde-exposed
+# preprocessor that needs onnxruntime; running it without the extra would abort the whole preload.
+_ONNXRUNTIME_GATED_PREPROCESSORS = frozenset({"OpenposePreprocessor"})
+
 
 def _midas_already_cached() -> bool:
     """Return whether the transformers-based MiDaS annotator is fully in the HF cache.
@@ -167,6 +173,22 @@ def _run_preload(*, force_offline: bool) -> bool:
         aio_preprocessor_class = get_node_class("AIO_Preprocessor")
 
         preprocessors = sorted(set(HordeLib.CONTROLNET_IMAGE_PREPROCESSOR_MAP.values()))
+        # On a lean base install (no `controlnet` extra) the onnxruntime-backed detectors never
+        # registered; preloading them would raise and abort the whole run. Drop them and preload the
+        # rest, which are pure-torch / transformers and work without the extra.
+        from hordelib.feature_impact import FEATURE_KIND
+        from hordelib.feature_requirements import feature_available
+
+        if not feature_available(FEATURE_KIND.controlnet):
+            skipped = sorted(_ONNXRUNTIME_GATED_PREPROCESSORS.intersection(preprocessors))
+            if skipped:
+                logger.info(
+                    "Skipping controlnet annotators that need the 'controlnet' extra (onnxruntime "
+                    "absent): preprocessors={}",
+                    skipped,
+                )
+                preprocessors = [p for p in preprocessors if p not in _ONNXRUNTIME_GATED_PREPROCESSORS]
+
         # A tiny gray test card; enough for every detector to run its model once
         test_image = torch.full((1, 64, 64, 3), 0.5)
 

{horde_engine-3.1.2 → horde_engine-3.2.2}/hordelib/utils/gpuinfo.py

@@ -92,7 +92,12 @@ class GPUInfo:
 
     def get_info(self):
         if not self.is_nvidia():
-            return GPUInfoResult.get_empty_info()
+            from hordelib.utils.torch_memory import get_torch_free_vram_mb, get_torch_total_vram_mb
+
+            return GPUInfoResult.get_empty_info(
+                vram_total_mb=get_torch_total_vram_mb(),
+                vram_free_mb=get_torch_free_vram_mb(),
+            )
 
         data = self._get_gpu_data()
         if not data:
@@ -180,16 +185,17 @@ class GPUInfoResult(BaseModel):
         return final_string
 
     @classmethod
-    def get_empty_info(cls):
+    def get_empty_info(cls, vram_total_mb: int = 0, vram_free_mb: int = 0):
+        vram_used_mb = max(vram_total_mb - vram_free_mb, 0)
         return GPUInfoResult(
             supported=False,
-            product="unknown (stats with AMD not supported)",
+            product="unknown (detailed stats unavailable on this backend)",
             pci_gen="?",
             pci_width="?",
             fan_speed=("0", Unit.percent),
-            vram_total=(0, Unit.megabytes),
-            vram_used=(0, Unit.megabytes),
-            vram_free=(0, Unit.megabytes),
+            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),

{horde_engine-3.1.2 → horde_engine-3.2.2}/hordelib/utils/image_utils.py

@@ -1,7 +1,6 @@
 import base64
 
 import numpy as np
-import rembg  # type: ignore
 from loguru import logger
 from PIL import Image, ImageOps, PngImagePlugin, UnidentifiedImageError
 
@@ -317,6 +316,13 @@ class ImageUtils:
 
     @classmethod
     def strip_background(cls, image: Image.Image):
+        # rembg (and its onnxruntime backend) is imported lazily and is no longer a base dependency:
+        # it lives in the optional [rembg] extra (onnxruntime has no XPU/MPS/Ascend wheels). On a lean
+        # base install this gate raises an actionable MissingOptionalDependency rather than dragging the
+        # heavy onnxruntime stack onto every ImageUtils import. See hordelib.feature_requirements.
+        from hordelib.utils.optional_deps import import_optional
+
+        rembg = import_optional("rembg", extra="rembg", feature="strip_background (background removal)")
         session = rembg.new_session("u2net")
         image = rembg.remove(
             image,

horde_engine-3.2.2/hordelib/utils/optional_deps.py

@@ -0,0 +1,74 @@
+"""Lazy optional-dependency gating for hordelib.
+
+hordelib aims to stay close to base ComfyUI: heavy or platform-constrained features are
+guarded so that the packages they need are only required when the feature is actually used.
+A call site asks for an optional package via :func:`require` or :func:`import_optional`; if
+the package is absent the caller gets an actionable "install this extra" error instead of a
+bare ``ModuleNotFoundError`` surfacing from deep in the call stack.
+
+This module intentionally only DETECTS dependencies (via ``importlib.util.find_spec``); it
+never installs anything at runtime. Extras are resolved at lock/sync time by the packaging
+tool, which keeps environments reproducible and auditable (the opposite of runtime
+``pip install`` machinery).
+"""
+
+import importlib
+import importlib.util
+from types import ModuleType
+
+__all__ = ["MissingOptionalDependency", "import_optional", "require"]
+
+# The PyPI distribution name differs from the import name (`hordelib`); install hints must use
+# the distribution name so `pip install ...[extra]` actually works.
+_DISTRIBUTION_NAME = "horde-engine"
+
+
+class MissingOptionalDependency(ImportError):
+    """Raised when an optional feature is used but its backing package is not installed."""
+
+    def __init__(self, package: str, *, extra: str, feature: str) -> None:
+        self.package = package
+        self.extra = extra
+        self.feature = feature
+        super().__init__(
+            f"{feature} requires the optional package '{package}', which is not installed. "
+            f"Install it with: pip install {_DISTRIBUTION_NAME}[{extra}]",
+        )
+
+
+def require(package: str, *, extra: str, feature: str) -> None:
+    """Ensure an optional dependency is importable, or raise an actionable error.
+
+    Args:
+        package: The top-level import name to probe (e.g. ``"rembg"``).
+        extra: The ``horde-engine`` extra that provides it (e.g. ``"rembg"``).
+        feature: Human-readable name of the feature needing it, used in the error message.
+
+    Raises:
+        MissingOptionalDependency: If ``package`` cannot be found in the environment.
+    """
+    if importlib.util.find_spec(package) is None:
+        raise MissingOptionalDependency(package, extra=extra, feature=feature)
+
+
+def import_optional(module: str, *, extra: str, feature: str) -> ModuleType:
+    """Import and return an optional module, raising an actionable error if it is absent.
+
+    The presence probe uses the top-level package of ``module`` so that, for example,
+    ``import_optional("horde_image_utilities.rembg", ...)`` reports the installable package
+    rather than the dotted submodule.
+
+    Args:
+        module: The (possibly dotted) module path to import.
+        extra: The ``horde-engine`` extra that provides it.
+        feature: Human-readable name of the feature needing it, used in the error message.
+
+    Returns:
+        The imported module.
+
+    Raises:
+        MissingOptionalDependency: If the module's top-level package is not installed.
+    """
+    top_level = module.split(".", 1)[0]
+    require(top_level, extra=extra, feature=feature)
+    return importlib.import_module(module)