horde-model-reference 7.2.0__tar.gz → 7.3.0__tar.gz

{horde_model_reference-7.2.0/src/horde_model_reference.egg-info → horde_model_reference-7.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: horde_model_reference
-Version: 7.2.0
+Version: 7.3.0
 Summary: A helper library providing a way to work with the lists of generation models, utility models, and any other related files required for the AI-Horde ecosystem.
 Author-email: tazlin <tazlin.on.github@gmail.com>, db0 <mail@dbzer0.com>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE

{horde_model_reference-7.2.0 → horde_model_reference-7.3.0}/scripts/hash_components.py

@@ -46,7 +46,6 @@ from horde_model_reference.component_hash import (
     ComponentKind,
     NoComponentTensorsError,
     RangeNotSupportedError,
-    UnsupportedComponentError,
     UnsupportedContainerError,
     component_kind_for_purpose,
     hash_embedded_component_url,
@@ -61,7 +60,7 @@ if TYPE_CHECKING:
     from horde_model_reference.model_reference_records import GenericModelRecord
 
 _SAFETENSORS_SUFFIX = ".safetensors"
-_EMBEDDED_VAE_KEY = "vae"
+_EMBEDDABLE_KINDS = (ComponentKind.VAE, ComponentKind.TEXT_ENCODERS)
 _DEFAULT_PRIMARY_URL = "https://models.aihorde.net"
 _APIKEY_ENV_VARS = ("AI_HORDE_API_KEY", "HORDE_API_KEY")
 _SUBMIT_OK_STATUSES = frozenset({200, 201, 202})
@@ -88,15 +87,13 @@ def _looks_like_safetensors(file_name: str, file_url: str) -> bool:
 def plan_component_hash_tasks(record: GenericModelRecord, *, skip_existing: bool) -> list[ComponentHashTask]:
     """Plan which components of *record* to hash, without doing any I/O.
 
-    Standalone component files are hashed whole. A model with no separate VAE file is treated as monolithic
-    and its primary safetensors files are probed for an embedded VAE. When *skip_existing* is set, downloads
-    that already carry the relevant hash are left alone.
+    Standalone component files are hashed whole. A model with no standalone file for a component kind is
+    treated as monolithic for that kind, and its primary safetensors files are probed for the embedded VAE
+    and text encoders. When *skip_existing* is set, components that already carry a hash are left alone.
     """
     downloads = record.config.download
-    has_standalone_vae = any(
-        component_kind_for_purpose(download.file_purpose) is ComponentKind.VAE for download in downloads
-    )
-    existing_embedded_vae = (record.config.embedded_component_hashes or {}).get(_EMBEDDED_VAE_KEY)
+    standalone_kinds = {component_kind_for_purpose(download.file_purpose) for download in downloads}
+    embedded_hashes = record.config.embedded_component_hashes or {}
 
     tasks: list[ComponentHashTask] = []
     for index, download in enumerate(downloads):
@@ -107,8 +104,14 @@ def plan_component_hash_tasks(record: GenericModelRecord, *, skip_existing: bool
             if skip_existing and download.content_hash is not None:
                 continue
             tasks.append(ComponentHashTask(index, download.file_url, kind, embedded=False))
-        elif not has_standalone_vae and not (skip_existing and existing_embedded_vae is not None):
-            tasks.append(ComponentHashTask(index, download.file_url, ComponentKind.VAE, embedded=True))
+            continue
+        # Primary checkpoint: probe for each embeddable component that has no standalone file of its own.
+        for embed_kind in _EMBEDDABLE_KINDS:
+            if embed_kind in standalone_kinds:
+                continue
+            if skip_existing and embedded_hashes.get(embed_kind.value) is not None:
+                continue
+            tasks.append(ComponentHashTask(index, download.file_url, embed_kind, embedded=True))
     return tasks
 
 
@@ -120,7 +123,7 @@ def _hash_task(task: ComponentHashTask, *, session: requests.Session) -> str | N
         return hash_standalone_component_url(task.url, session=session)
     except NoComponentTensorsError:
         return None
-    except (UnsupportedContainerError, UnsupportedComponentError) as skip_reason:
+    except UnsupportedContainerError as skip_reason:
         logger.debug("Not hashable ({}): {}", skip_reason, task.url)
         return None
     except (RangeNotSupportedError, requests.RequestException) as fetch_error:
@@ -132,7 +135,7 @@ def _record_hash(record: GenericModelRecord, task: ComponentHashTask, content_ha
     """Store *content_hash* on the record, on the download for a standalone file or in the embedded map."""
     if task.embedded:
         embedded = dict(record.config.embedded_component_hashes or {})
-        embedded[_EMBEDDED_VAE_KEY] = content_hash
+        embedded[task.kind.value] = content_hash
         record.config.embedded_component_hashes = embedded
     else:
         record.config.download[task.download_index].content_hash = content_hash

{horde_model_reference-7.2.0 → horde_model_reference-7.3.0}/src/horde_model_reference/_version.py

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

{horde_model_reference-7.2.0 → horde_model_reference-7.3.0}/src/horde_model_reference/canonical_components.py

@@ -1,16 +1,17 @@
 """The canonical set of shareable model components, and how it is derived from the reference.
 
 A component (a VAE or a text encoder) is worth sharing across processes only when several models use the
-byte-identical weights. This module holds the derived answer to "which component content-hashes are worth
+byte-identical weights. This module holds the derived answer to "which component identities are worth
 materialising once and sharing?" plus, for each, where a worker can obtain the standalone file (which model
-carries it, and whether as its own file or embedded in a checkpoint it must slice).
+carries it, and whether as its own file or embedded in a checkpoint it must extract).
 
-The set is derived centrally by the offline hashing pass and served as data, so every worker consumes one
-authoritative answer rather than each re-deriving it (and drifting). Derivation is by frequency with a
-curated override: a component shared by at least ``min_shared_models`` distinct models is promoted, an
-allowlist can force a specific hash in regardless of count, and a denylist can exclude one. The identity is
-the torch-free tensor-region hash from :mod:`horde_model_reference.component_hash`; the kind values match
-``on_disk_layout.COMPONENT_PURPOSE_FOLDERS`` so placement of a materialised file reuses that routing.
+The set is derived centrally and served as data, so every worker consumes one authoritative answer rather
+than each re-deriving it (and drifting). Derivation is by frequency with a curated override: a component
+shared by at least ``min_shared_models`` distinct models is promoted, an allowlist can force a specific hash
+in regardless of count, and a denylist can exclude one. The identity is the torch-free **content hash** (the
+tensor-region file hash), which is identical on every machine; the loaded-module hash is device- and
+dtype-dependent, so it is a machine-local runtime detail only and is never shipped here. The kind values
+match ``on_disk_layout.COMPONENT_PURPOSE_FOLDERS`` so a materialised file's placement reuses that routing.
 
 This module stays torch-free: it is pure reference data and grouping logic over already-computed hashes.
 """
@@ -61,12 +62,13 @@ class CanonicalComponentSource(BaseModel):
 
 
 class CanonicalComponent(BaseModel):
-    """A shareable component promoted to the canonical set, identified by its content hash."""
+    """A shareable component promoted to the canonical set, identified by its content (file) hash."""
 
     model_config = get_default_config()
 
     content_hash: str
-    """The torch-free tensor-region content hash identifying these weights."""
+    """The cross-platform-stable file-content identity the registry keys on (not the machine-dependent
+    loaded-module hash)."""
     kind: ComponentKind
     """The component kind (``vae`` or ``text_encoders``)."""
     shared_by_model_count: int
@@ -98,7 +100,8 @@ def _iter_component_candidates(
     """Yield every ``(content_hash, kind, source)`` a single record contributes.
 
     Split-file components come from each ``DownloadRecord`` that declares a component ``file_purpose`` and a
-    ``content_hash``; embedded components come from the record's ``embedded_component_hashes`` map.
+    ``content_hash``; embedded components come from the record's ``embedded_component_hashes`` map. A component
+    whose content hash is not yet populated contributes nothing.
     """
     config = record.config
     for download in config.download:
@@ -136,15 +139,15 @@ def derive_canonical_registry(
 ) -> CanonicalComponentRegistry:
     """Derive the canonical component set from *records* by frequency, with a curated override.
 
-    A ``(content_hash, kind)`` group is promoted when its hash is in *allow*, or when its hash is not in
+    A ``(content_hash, kind)`` group is promoted when its identity hash is in *allow*, or when it is not in
     *deny* and at least *min_shared_models* distinct models carry it. Sources are collected per group and
     deduplicated, so a worker can pick whichever carrier it already has on disk.
 
     Args:
         records: The reference, keyed by model name.
         min_shared_models: The frequency threshold for automatic promotion.
-        allow: Content hashes to force into the set regardless of count.
-        deny: Content hashes to exclude even when frequent.
+        allow: Module (identity) hashes to force into the set regardless of count.
+        deny: Module (identity) hashes to exclude even when frequent.
     """
     allow_set = set(allow)
     deny_set = set(deny)

{horde_model_reference-7.2.0 → horde_model_reference-7.3.0}/src/horde_model_reference/component_hash.py

@@ -15,15 +15,17 @@ Two forms are hashed, because a component can appear either as its own file or e
 * **standalone** (:func:`hash_standalone_component`): the file *is* the component (a split-file VAE or
   text-encoder). Every tensor is hashed with its bare key.
 * **embedded** (:func:`hash_embedded_component`): the component's tensors are selected out of a monolithic
-  checkpoint by their known key prefix, and that prefix is stripped so the result equals the standalone
-  hash of the same weights extracted to their own file.
+  checkpoint by their known key prefix, and that prefix is stripped.
 
-Embedded extraction is supported for the **VAE only**. In a monolithic checkpoint ComfyUI does not merely
-prefix the text-encoder weights, it renames and structurally reshuffles them at load time (SD1.5/SDXL fold
+For the **VAE**, the embedded hash equals the standalone hash of the same weights extracted to their own
+file (ComfyUI strips the VAE prefix cleanly, no key renaming). For **text encoders** it does not: in a
+monolithic checkpoint ComfyUI renames and structurally reshuffles them at load (SD1.5/SDXL fold
 ``conditioner.embedders.*`` into ``clip_l``/``clip_g`` and convert the OpenCLIP layout, which fuses/splits
-tensors), so a torch-free file hash cannot reproduce the standalone form without reimplementing that
-loader. Embedded text-encoder hashing therefore raises :class:`UnsupportedComponentError`; text-encoder
-sharing is served by the split-file families (Flux/Qwen/Z-Image), whose encoders are already standalone.
+tensors), so a torch-free file hash cannot reproduce a standalone text-encoder file. The embedded
+text-encoder hash is therefore a stable identity matched only against *other monolithic checkpoints* (which
+all store the encoders the same way) and the lane's representative-checkpoint load, never against a
+standalone text-encoder file. Split-file families (Flux/Qwen/Z-Image) ship their encoders standalone and use
+the standalone hash directly.
 
 This module stays inside :mod:`horde_model_reference`'s torch-free boundary (enforced by
 ``tests/test_torch_free_imports.py``): it parses the safetensors header with the stdlib and hashes byte
@@ -59,7 +61,6 @@ __all__ = [
     "NoComponentTensorsError",
     "RangeNotSupportedError",
     "RegionReader",
-    "UnsupportedComponentError",
     "UnsupportedContainerError",
     "component_kind_for_purpose",
     "hash_embedded_component",
@@ -101,12 +102,22 @@ the strip is a pure leading-substring removal with no key renaming, so stripping
 bare ``encoder.``/``decoder.`` keys a standalone VAE file carries."""
 
 
-class UnsupportedContainerError(ValueError):
-    """Raised when a file is not a parseable safetensors container (e.g. a pickle ``.ckpt``)."""
+_EMBEDDED_TE_PREFIXES: tuple[str, ...] = ("conditioner.embedders.", "cond_stage_model.")
+"""Key prefixes under which a monolithic checkpoint stores its text encoders (SDXL
+``conditioner.embedders.0/1.``, SD1.5 ``cond_stage_model.``). Unlike the VAE, ComfyUI renames and reshuffles
+these keys at load, so this hash does NOT equal a standalone text-encoder file; it is a stable identity for a
+monolithic checkpoint's text encoders, matched only against other monolithic checkpoints (and the lane's
+representative-checkpoint load), which all store them identically."""
 
 
-class UnsupportedComponentError(ValueError):
-    """Raised when embedded extraction is requested for a component kind it is not supported for."""
+_EMBEDDED_PREFIXES: dict[ComponentKind, tuple[str, ...]] = {
+    ComponentKind.VAE: _EMBEDDED_VAE_PREFIXES,
+    ComponentKind.TEXT_ENCODERS: _EMBEDDED_TE_PREFIXES,
+}
+
+
+class UnsupportedContainerError(ValueError):
+    """Raised when a file is not a parseable safetensors container (e.g. a pickle ``.ckpt``)."""
 
 
 class NoComponentTensorsError(LookupError):
@@ -304,13 +315,14 @@ def _select_standalone_tensors(header: dict[str, object]) -> list[ComponentTenso
     return selected
 
 
-def _select_embedded_vae_tensors(header: dict[str, object]) -> list[ComponentTensor]:
-    """Select the VAE tensors from a monolithic checkpoint, stripping the checkpoint prefix to bare keys."""
+def _select_embedded_tensors(header: dict[str, object], kind: ComponentKind) -> list[ComponentTensor]:
+    """Select *kind*'s tensors from a monolithic checkpoint, stripping the checkpoint prefix to bare keys."""
+    prefixes = _EMBEDDED_PREFIXES[kind]
     selected: list[ComponentTensor] = []
     for name, entry in header.items():
         if name == "__metadata__":
             continue
-        prefix = next((candidate for candidate in _EMBEDDED_VAE_PREFIXES if name.startswith(candidate)), None)
+        prefix = next((candidate for candidate in prefixes if name.startswith(candidate)), None)
         if prefix is None:
             continue
         tensor = _tensor_from_entry(name[len(prefix) :], entry)
@@ -362,22 +374,20 @@ def hash_standalone_component(reader: RegionReader) -> str:
 
 
 def hash_embedded_component(reader: RegionReader, kind: ComponentKind) -> str:
-    """Return the normalized content hash of *kind* extracted from a monolithic checkpoint read via *reader*.
+    """Return the content hash of *kind* selected from a monolithic checkpoint read via *reader*.
 
-    Only :attr:`ComponentKind.VAE` is supported; the result equals :func:`hash_standalone_component` of the
-    same VAE extracted to its own file.
+    The embedded VAE hash equals :func:`hash_standalone_component` of the same VAE extracted to its own file
+    (ComfyUI strips the VAE prefix cleanly). The embedded text-encoder hash does NOT equal a standalone
+    text-encoder file (ComfyUI renames those keys at load); it is a stable identity for a monolithic
+    checkpoint's text encoders, matched only against other monolithic checkpoints that store them identically.
+    Both are file-content hashes, independent of platform, device and load-time dtype selection.
 
     Raises:
-        UnsupportedComponentError: *kind* has no supported embedded extraction (any text encoder).
         UnsupportedContainerError: The source is not a parseable safetensors container.
         NoComponentTensorsError: The checkpoint holds no tensors for *kind*.
     """
-    if kind is not ComponentKind.VAE:
-        raise UnsupportedComponentError(
-            f"Embedded extraction is not supported for {kind}; it is served by split-file component files.",
-        )
     header, data_start = _parse_safetensors_header(reader)
-    tensors = _select_embedded_vae_tensors(header)
+    tensors = _select_embedded_tensors(header, kind)
     if not tensors:
         raise NoComponentTensorsError(f"No embedded {kind} tensors found in checkpoint.")
     return _hash_selected(reader, data_start, tensors)

{horde_model_reference-7.2.0 → horde_model_reference-7.3.0}/src/horde_model_reference/legacy/classes/legacy_converters.py

@@ -60,10 +60,10 @@ def image_generation_record_to_legacy_dict(record: GenericModelRecord) -> dict[s
     """Convert a v2 image-generation record to a legacy ``stable_diffusion.json`` entry dict.
 
     Inverts the legacy-to-v2 config split: each v2 download becomes a legacy ``files`` entry (carrying its
-    ``sha256sum``, ``file_type`` from ``file_purpose`` and the new ``content_hash``) plus a ``download``
-    entry (carrying the URL), and the config's ``embedded_component_hashes`` is preserved. The baseline is
-    mapped back to its legacy string form where one exists (otherwise passed through). The result validates
-    against :class:`LegacyStableDiffusionRecord`.
+    ``sha256sum``, ``file_type`` from ``file_purpose`` and the component ``content_hash``) plus a
+    ``download`` entry (carrying the URL), and the config's ``embedded_component_hashes`` is preserved. The
+    baseline is mapped back to its legacy string form where one exists (otherwise passed through). The result
+    validates against :class:`LegacyStableDiffusionRecord`.
 
     The mapping is intentionally lossy in one direction: v2-only metadata that has no legacy counterpart
     (record ``metadata``, ``model_classification``, ``finetune_series``) is dropped. The goal is a minimal,

{horde_model_reference-7.2.0 → horde_model_reference-7.3.0}/src/horde_model_reference/legacy/classes/legacy_models.py

@@ -83,8 +83,8 @@ class LegacyConfigFile(BaseModel):
     file_type: str | None = None
     content_hash: str | None = None
     """The normalized tensor-region content hash of this component file (distinct from the whole-file
-    ``sha256sum``), used to identify byte-equivalent components for cross-process sharing. ``None`` when
-    unknown or unhashable."""
+    ``sha256sum``): the cross-platform-stable identity used for cross-process sharing. ``None`` when unknown
+    or unhashable."""
 
     @model_validator(mode="after")
     def _ensure_sha256sum_for_model_files(self, info: ValidationInfo) -> LegacyConfigFile:
@@ -138,9 +138,9 @@ class LegacyConfig(BaseModel):
     files: list[LegacyConfigFile] = Field(default_factory=list)
     download: list[LegacyConfigDownload] = Field(default_factory=list)
     embedded_component_hashes: dict[str, str] | None = None
-    """Maps a component kind (``vae``, ``text_encoders``) to the normalized tensor-region content hash of
-    that component embedded in the primary checkpoint. ``None`` when the model embeds no shareable
-    component or is unhashable."""
+    """Maps a component kind (``vae``, ``text_encoders``) to the tensor-region content hash of that component
+    embedded in the primary checkpoint: the cross-platform-stable identity for cross-process sharing. ``None``
+    when the model embeds no shareable component or is unhashable."""
 
     @classmethod
     def _coerce_config_dict(cls, value: object, info: ValidationInfo) -> dict[str, Any]:
@@ -149,9 +149,10 @@ class LegacyConfig(BaseModel):
         if not isinstance(value, dict):
             raise TypeError("config entries must be provided as a mapping")
         raw_dict: dict[str, object] = {str(k): v for k, v in value.items()}
-        # embedded_component_hashes is a legitimate third config entry; it is not one of the legacy
-        # files/download pair the ">2 entries" heuristic guards against.
-        countable = {key: value for key, value in raw_dict.items() if key != "embedded_component_hashes"}
+        # The embedded-hash maps are legitimate extra config entries, not part of the legacy files/download
+        # pair the ">2 entries" heuristic guards against.
+        embedded_keys = ("embedded_component_hashes",)
+        countable = {key: value for key, value in raw_dict.items() if key not in embedded_keys}
         if len(countable) > 2:
             _record_issue(info, "has more than 2 config entries.")
         coerced: dict[str, Any] = {}
@@ -160,8 +161,9 @@ class LegacyConfig(BaseModel):
             if not isinstance(entries, Iterable):
                 raise TypeError(f"config[{key!s}] must be iterable")
             coerced[key] = list(entries)
-        if raw_dict.get("embedded_component_hashes") is not None:
-            coerced["embedded_component_hashes"] = raw_dict["embedded_component_hashes"]
+        for key in embedded_keys:
+            if raw_dict.get(key) is not None:
+                coerced[key] = raw_dict[key]
         return coerced
 
     _coerce_config_dict = model_validator(mode="before")(_coerce_config_dict)  # type: ignore[assignment]  # Pydantic wraps the classmethod in a descriptor proxy

{horde_model_reference-7.2.0 → horde_model_reference-7.3.0}/src/horde_model_reference/model_reference_records.py

@@ -66,8 +66,10 @@ class DownloadRecord(BaseModel):  # TODO Rename? (record to subrecord?)
 
     Distinct from the whole-file :attr:`sha256sum`: it hashes only the component's tensor payload (sorted by
     name, folding in dtype/shape/bytes and excluding container metadata and key ordering), so byte-equivalent
-    VAE/text-encoder weights shipped in different containers share one hash. Used to identify components that
-    can be shared across processes. ``None`` when unknown or unhashable (e.g. a ``.ckpt`` pickle file)."""
+    VAE/text-encoder weights shipped in different containers share one hash. This cross-platform-stable value
+    (a pure function of the file bytes, independent of device and load-time dtype) is the identity the
+    canonical registry keys on for cross-process sharing. ``None`` when unknown or unhashable (e.g. a
+    ``.ckpt`` pickle file)."""
     file_purpose: str | None = None
     """The role this file plays for the model (e.g. ``"vae"`` or ``"text_encoders"``).
 

{horde_model_reference-7.2.0 → horde_model_reference-7.3.0/src/horde_model_reference.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: horde_model_reference
-Version: 7.2.0
+Version: 7.3.0
 Summary: A helper library providing a way to work with the lists of generation models, utility models, and any other related files required for the AI-Horde ecosystem.
 Author-email: tazlin <tazlin.on.github@gmail.com>, db0 <mail@dbzer0.com>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE

horde_model_reference-7.3.0/src/horde_model_reference.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "7.3.0",
+  "distance": 0,
+  "node": "g0d95c3fff084fd7e15c2f01f865a81b3907195e3",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-05"
+}

{horde_model_reference-7.2.0 → horde_model_reference-7.3.0}/tests/test_component_hash.py

@@ -17,7 +17,6 @@ import pytest
 from horde_model_reference.component_hash import (
     ComponentKind,
     NoComponentTensorsError,
-    UnsupportedComponentError,
     UnsupportedContainerError,
     component_kind_for_purpose,
     hash_embedded_component_file,
@@ -113,15 +112,22 @@ def test_embedded_vae_matches_standalone(tmp_path: Path, vae_prefix: str) -> Non
     assert hash_embedded_component_file(checkpoint, ComponentKind.VAE) == hash_standalone_component_file(standalone)
 
 
-def test_embedded_text_encoder_unsupported(tmp_path: Path) -> None:
-    """Embedded text-encoder extraction is refused (ComfyUI renames those keys)."""
+def test_embedded_text_encoder_is_hashed(tmp_path: Path) -> None:
+    """Embedded text encoders hash consistently across checkpoints, independent of UNet/VAE and stable."""
+    te = [
+        ("conditioner.embedders.0.weight", "F32", (1, 2), bytes(range(16, 24))),
+        ("conditioner.embedders.1.weight", "F16", (2, 2), bytes(range(1, 9))),
+    ]
     checkpoint = _write(
         tmp_path,
         "ckpt.safetensors",
-        [("conditioner.embedders.0.y", "F32", (1,), bytes(range(50, 54)))],
+        [("model.diffusion_model.x", "F16", (2,), bytes(range(40, 44))), *te],
     )
-    with pytest.raises(UnsupportedComponentError):
-        hash_embedded_component_file(checkpoint, ComponentKind.TEXT_ENCODERS)
+    te_hash = hash_embedded_component_file(checkpoint, ComponentKind.TEXT_ENCODERS)
+    # A different checkpoint carrying the same text encoders (different UNet) hashes equal.
+    other_unet = ("model.diffusion_model.x", "F16", (3,), bytes(range(60, 66)))
+    other = _write(tmp_path, "other.safetensors", [other_unet, *te])
+    assert hash_embedded_component_file(other, ComponentKind.TEXT_ENCODERS) == te_hash
 
 
 def test_embedded_vae_missing_raises(tmp_path: Path) -> None:

{horde_model_reference-7.2.0 → horde_model_reference-7.3.0}/tests/test_hash_components_script.py

@@ -47,13 +47,12 @@ def test_split_file_plans_standalone_not_embedded() -> None:
     }
 
 
-def test_monolithic_plans_embedded_vae() -> None:
-    """A monolithic checkpoint (no separate VAE) is probed for an embedded VAE."""
+def test_monolithic_plans_embedded_vae_and_te() -> None:
+    """A monolithic checkpoint (no separate component files) is probed for embedded VAE and text encoders."""
     record = _record([_download("sdxl_finetune.safetensors")])
     tasks = plan_component_hash_tasks(record, skip_existing=False)
-    assert len(tasks) == 1
-    assert tasks[0].embedded is True
-    assert tasks[0].kind is ComponentKind.VAE
+    assert all(task.embedded for task in tasks)
+    assert {task.kind for task in tasks} == {ComponentKind.VAE, ComponentKind.TEXT_ENCODERS}
 
 
 def test_non_safetensors_is_skipped() -> None:
@@ -69,7 +68,11 @@ def test_skip_existing_standalone_hash() -> None:
     assert len(plan_component_hash_tasks(record, skip_existing=False)) == 1
 
 
-def test_skip_existing_embedded_vae() -> None:
-    """skip_existing leaves an already-recorded embedded VAE alone."""
-    record = _record([_download("sdxl_finetune.safetensors")], embedded={"vae": "e" * 64})
+def test_skip_existing_embedded_components() -> None:
+    """skip_existing leaves already-recorded embedded components alone."""
+    record = _record(
+        [_download("sdxl_finetune.safetensors")],
+        embedded={"vae": "e" * 64, "text_encoders": "f" * 64},
+    )
     assert plan_component_hash_tasks(record, skip_existing=True) == []
+    assert len(plan_component_hash_tasks(record, skip_existing=False)) == 2

horde_model_reference-7.2.0/src/horde_model_reference.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "7.2.0",
-  "distance": 0,
-  "node": "g320a47a13ccd705aae78c49c56aa6c8b13d2cc95",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-07-04"
-}