horde-engine 3.6.0__tar.gz → 3.6.2__tar.gz

{horde_engine-3.6.0 → horde_engine-3.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: horde-engine
-Version: 3.6.0
+Version: 3.6.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

{horde_engine-3.6.0 → horde_engine-3.6.2}/hordelib/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.6.0'
-__version_tuple__ = version_tuple = (3, 6, 0)
+__version__ = version = '3.6.2'
+__version_tuple__ = version_tuple = (3, 6, 2)
 
 __commit_id__ = commit_id = None

{horde_engine-3.6.0 → horde_engine-3.6.2}/hordelib/feature_impact.py

@@ -251,13 +251,18 @@ _BASELINE_SEEDS: list[BaselineBurden] = [
     ),
     BaselineBurden(
         baseline="z_image_turbo",
-        vram_base_mb=8000,
+        vram_base_mb=11000,
         ram_base_mb=14000,
         vram_per_megapixel_mb=1200,
         native_resolution=(1024, 1024),
-        min_recommended_vram_mb=10000,
+        min_recommended_vram_mb=12000,
         max_recommended_batch=2,
         typical_disk_gb=8.0,
+        # The 6B DiT plus its text encoder and VAE stay resident together; the prior unseeded base of 8000
+        # conflated weights with activations and read as comfortably co-resident, so the scheduler never gave
+        # Z-Image the whole card it actually wants. Seeded explicitly so the streaming/residency forecast sees
+        # the real weight footprint at the worker's typical dtype.
+        vram_weights_mb=10000,
     ),
 ]
 

{horde_engine-3.6.0 → horde_engine-3.6.2}/hordelib/nodes/node_model_loader.py

@@ -261,7 +261,14 @@ def make_circular(m):
 
 
 def make_circular_vae(m):
-    m.first_stage_model.apply(make_circular)
+    # Not every VAE exposes a `first_stage_model`: newer architectures (e.g. Z-Image/Lumina2) return a
+    # VAE whose `first_stage_model` is None, so reaching into it to retune Conv2d padding would raise and
+    # take down the whole load. Seamless tiling simply doesn't apply to those, so skip it rather than fault.
+    first_stage_model = getattr(m, "first_stage_model", None)
+    if first_stage_model is None:
+        logger.debug("VAE has no first_stage_model; skipping circular tiling for this architecture")
+        return
+    first_stage_model.apply(make_circular)
 
 
 def make_regular(m):
@@ -270,7 +277,11 @@ def make_regular(m):
 
 
 def make_regular_vae(m):
-    m.first_stage_model.apply(make_regular)
+    first_stage_model = getattr(m, "first_stage_model", None)
+    if first_stage_model is None:
+        logger.debug("VAE has no first_stage_model; skipping regular tiling for this architecture")
+        return
+    first_stage_model.apply(make_regular)
 
 
 NODE_CLASS_MAPPINGS = {"HordeCheckpointLoader": HordeCheckpointLoader}

horde_engine-3.6.2/hordelib/utils/device_pinning.py

@@ -0,0 +1,96 @@
+"""Single source of truth for masking a subprocess to one compute device.
+
+Each inference child process is pinned to exactly one device so that every
+single-device assumption in ComfyUI and hordelib (``cuda:0``, module-level
+``total_vram``, ``UserSettings._vram_to_leave_free_mb``) stays correct without
+modification inside that child. The orchestrator (which is torch-free) calls
+:func:`device_pin_env` to get the env-var patch and extra ComfyUI CLI args it
+must apply before spawning the child; the child itself applies them before
+calling ``hordelib.initialise()``.
+
+:func:`device_pin_env` is the only function here. All callers (worker entry
+points, ``hordelib.initialise``'s optional convenience path) must go through
+it so that backend-specific masking details stay in one place.
+"""
+
+from __future__ import annotations
+
+import os
+
+from hordelib.utils.torch_memory import AcceleratorKind
+
+
+def _resolve_physical_id(env_var: str, logical_index: int) -> str:
+    """Translate a logical device index into the physical device identifier for ``env_var``.
+
+    When the user restricts visible devices via an environment variable (e.g.
+    ``CUDA_VISIBLE_DEVICES=0,2``), torch and ComfyUI re-index the visible set as 0, 1, 2, ...
+    :func:`~hordelib.utils.torch_memory.enumerate_accelerators` returns these **logical** indices.
+    Writing the logical index directly into the child's env var would pin it to the wrong physical
+    device; this function resolves back to the physical identifier at ``logical_index``'s position
+    in the current visible list so the child's env var is correct.
+
+    When the variable is unset or empty every logical index equals its physical counterpart, so
+    ``str(logical_index)`` is returned unchanged. UUID-format entries (``GPU-...``) are passed
+    through as-is, as are any special sentinel values (``NoDevFiles``, ``-1``).
+
+    Args:
+        env_var: The environment variable name to read (e.g. ``"CUDA_VISIBLE_DEVICES"``).
+        logical_index: The 0-based index within the currently visible device set.
+
+    Returns:
+        The physical device identifier (integer string or UUID) for the child's env var.
+
+    Raises:
+        IndexError: If ``logical_index`` is out of range for the current visible set.
+    """
+    current = os.environ.get(env_var, "")
+    if not current:
+        return str(logical_index)
+    entries = [e.strip() for e in current.split(",")]
+    return entries[logical_index]
+
+
+def device_pin_env(kind: AcceleratorKind, index: int) -> tuple[dict[str, str], list[str]]:
+    """Return the env-var patch and extra ComfyUI args that restrict a process to device ``index``.
+
+    ``index`` is the **logical** index as returned by
+    :func:`~hordelib.utils.torch_memory.enumerate_accelerators` (0-based within whatever device
+    set is currently visible to this process). When the caller's environment already restricts
+    visible devices via ``CUDA_VISIBLE_DEVICES`` or equivalent, the logical index is translated
+    back to the physical device identifier so the child's env var pins the correct card.
+
+    After applying both return values, the OS/driver presents only that one device to the process
+    and it becomes ``cuda:0`` (or the backend equivalent), so all single-device assumptions inside
+    hordelib and the vendored ComfyUI remain correct without any code changes there.
+
+    Args:
+        kind: The :class:`~hordelib.utils.torch_memory.AcceleratorKind` of the target device.
+        index: The **logical** device index (as reported by
+            :func:`~hordelib.utils.torch_memory.enumerate_accelerators`).
+
+    Returns:
+        A 2-tuple ``(env_vars, extra_args)`` where ``env_vars`` is a dict to merge into
+        ``os.environ`` and ``extra_args`` is a list of CLI arguments to append to
+        ``extra_comfyui_args``. Either or both may be empty when the backend needs no masking
+        (cpu, mps).
+    """
+    if kind is AcceleratorKind.cuda:
+        physical = _resolve_physical_id("CUDA_VISIBLE_DEVICES", index)
+        return {"CUDA_VISIBLE_DEVICES": physical}, []
+
+    if kind is AcceleratorKind.rocm:
+        # ROCm presents through torch.cuda, so CUDA_VISIBLE_DEVICES is honoured too; keep both in sync.
+        physical = _resolve_physical_id("HIP_VISIBLE_DEVICES", index)
+        return {"HIP_VISIBLE_DEVICES": physical, "CUDA_VISIBLE_DEVICES": physical}, []
+
+    if kind is AcceleratorKind.xpu:
+        physical = _resolve_physical_id("ZE_AFFINITY_MASK", index)
+        return {"ZE_AFFINITY_MASK": physical}, []
+
+    if kind is AcceleratorKind.directml:
+        # DirectML device selection happens via a ComfyUI CLI flag, not an env var.
+        return {}, ["--directml", str(index)]
+
+    # cpu and mps have no multi-device isolation mechanism; masking is a no-op.
+    return {}, []

horde_engine-3.6.0/hordelib/utils/device_pinning.py

@@ -1,54 +0,0 @@
-"""Single source of truth for masking a subprocess to one compute device.
-
-Each inference child process is pinned to exactly one device so that every
-single-device assumption in ComfyUI and hordelib (``cuda:0``, module-level
-``total_vram``, ``UserSettings._vram_to_leave_free_mb``) stays correct without
-modification inside that child. The orchestrator (which is torch-free) calls
-:func:`device_pin_env` to get the env-var patch and extra ComfyUI CLI args it
-must apply before spawning the child; the child itself applies them before
-calling ``hordelib.initialise()``.
-
-:func:`device_pin_env` is the only function here. All callers (worker entry
-points, ``hordelib.initialise``'s optional convenience path) must go through
-it so that backend-specific masking details stay in one place.
-"""
-
-from __future__ import annotations
-
-from hordelib.utils.torch_memory import AcceleratorKind
-
-
-def device_pin_env(kind: AcceleratorKind, index: int) -> tuple[dict[str, str], list[str]]:
-    """Return the env-var patch and extra ComfyUI args that restrict a process to device ``index``.
-
-    After applying both, the OS/driver presents only that one device to the process and it
-    becomes ``cuda:0`` (or the backend equivalent), so all single-device assumptions inside
-    hordelib and the vendored ComfyUI remain correct without any code changes there.
-
-    Args:
-        kind: The :class:`~hordelib.utils.torch_memory.AcceleratorKind` of the target device.
-        index: The **global** device index (as reported by
-            :func:`~hordelib.utils.torch_memory.enumerate_accelerators`).
-
-    Returns:
-        A 2-tuple ``(env_vars, extra_args)`` where ``env_vars`` is a dict to merge into
-        ``os.environ`` and ``extra_args`` is a list of CLI arguments to append to
-        ``extra_comfyui_args``. Either or both may be empty when the backend needs no masking
-        (cpu, mps).
-    """
-    if kind is AcceleratorKind.cuda:
-        return {"CUDA_VISIBLE_DEVICES": str(index)}, []
-
-    if kind is AcceleratorKind.rocm:
-        # ROCm presents through torch.cuda, so CUDA_VISIBLE_DEVICES is honoured too; keep them in sync.
-        return {"HIP_VISIBLE_DEVICES": str(index), "CUDA_VISIBLE_DEVICES": str(index)}, []
-
-    if kind is AcceleratorKind.xpu:
-        return {"ZE_AFFINITY_MASK": str(index)}, []
-
-    if kind is AcceleratorKind.directml:
-        # DirectML device selection happens via a ComfyUI CLI flag, not an env var.
-        return {}, ["--directml", str(index)]
-
-    # cpu and mps have no multi-device isolation mechanism; masking is a no-op.
-    return {}, []