tracebloc 1.2.74__tar.gz → 1.2.76__tar.gz

{tracebloc-1.2.74 → tracebloc-1.2.76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tracebloc
-Version: 1.2.74
+Version: 1.2.76
 Summary: Build AI with anyone. On data that can't move. SDK for the tracebloc collaborative AI workspace.
 Author-email: tracebloc <lukas@tracebloc.io>
 License-Expression: MIT

{tracebloc-1.2.74 → tracebloc-1.2.76}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tracebloc"
-version = "1.2.74"
+version = "1.2.76"
 description = "Build AI with anyone. On data that can't move. SDK for the tracebloc collaborative AI workspace."
 license = "MIT"
 license-files = ["license.txt"]

{tracebloc-1.2.74 → tracebloc-1.2.76}/tracebloc/_upload_conversion.py

@@ -5,7 +5,7 @@ untouched. Anything else (a Hugging Face folder, a checkpoint, the peer's own
 code, a live object) goes through the converter, whose package is uploaded
 only once its acceptance check passed and its licence is confirmed. The use
 case's task comes from ``dataset_id``: ``dataset/<dataset_id>/task/`` answers
-it for a dataset the peer can link a model to.
+it for a dataset the peer can link a model to, and its 404 refuses any other.
 """
 
 from __future__ import annotations
@@ -32,12 +32,8 @@ from tracebloc.validation.header_rules import NO_OUTPUT_CLASSES
 
 #: A dataset's category and counts, for a dataset the peer can link a model to.
 DATASET_TASK_PATH = "dataset/{dataset_id}/task/"
-#: The use cases the peer can see, each with its training dataset.
-USE_CASES_PATH = "competition/"
 #: ``licence_confirmed``'s default: ask the peer, in a notebook only.
 ASK = "ask"
-#: How many pages of use cases are read before giving up on a dataset.
-MAX_PAGES = 20
 
 
 @dataclass(frozen=True)
@@ -83,67 +79,15 @@ def _not_found(dataset_id: str) -> ModelValidationError:
     )
 
 
-def _route_missing(response: Any) -> bool:
-    """True for a 404 the server's URL routing answered rather than the view:
-    the API's own 404 is JSON ``{"detail": ...}``, an unknown URL's page is not."""
-    try:
-        body = response.json()
-    except ValueError:
-        return True
-    return not (isinstance(body, Mapping) and "detail" in body)
-
-
-def _class_count(dataset: Mapping[str, Any]) -> int | None:
-    meta = dataset.get("dataset_meta")
-    counts = meta.get("count") if isinstance(meta, Mapping) else None
-    labels = counts.get("label") if isinstance(counts, Mapping) else None
-    return len(labels) if isinstance(labels, (Mapping, list)) and labels else None
-
-
-def _use_cases(client: Any) -> Any:
-    """Every use case ``competition/`` lists for the peer, page by page."""
-    for page in range(1, MAX_PAGES + 1):
-        response = client.get(
-            USE_CASES_PATH, params={"page": page}, raise_on_error=False
-        )
-        if response.status_code != 200:
-            raise APIError(response.status_code, "the use cases could not be read")
-        body = _json(response, "the use cases")
-        yield from body.get("results", []) if isinstance(body, Mapping) else body
-        if not isinstance(body, Mapping) or not body.get("next"):
-            return
-
-
-def _task_from_use_cases(client: Any, dataset_id: str) -> UseCaseTask:
-    """The task of the use case whose training dataset is ``dataset_id``, for a
-    server without ``dataset/<dataset_id>/task/``: its category, and its class
-    count when the dataset records its labels."""
-    for use_case in _use_cases(client):
-        dataset = use_case.get("dataset") or {}
-        if dataset_id not in (use_case.get("dataset_key"), dataset.get("dataset_key")):
-            continue
-        category = _category(dataset, dataset_id)
-        classes = _class_count(dataset)
-        counts = {}
-        if classes is not None and category not in NO_OUTPUT_CLASSES:
-            counts["output_classes"] = classes
-        return UseCaseTask(category, from_use_case=True, counts=counts)
-    raise _not_found(dataset_id)
-
-
 def dataset_task(client: Any, dataset_id: str) -> UseCaseTask:
     """The task of ``dataset_id``, a dataset the peer can link a model to.
 
     Its category, and every count the server records for it; a class count
-    only for a task with a class per label.
+    only for a task with a class per label. A 404 is the dataset's refusal.
     """
     path = DATASET_TASK_PATH.format(dataset_id=quote(str(dataset_id), safe=""))
     response = client.get(path, raise_on_error=False)
     if response.status_code == 404:
-        if _route_missing(response):
-            # TODO(tracebloc/tracebloc-py-package#1059): a server older than
-            # dataset/<key>/task/ answers the task from its use cases.
-            return _task_from_use_cases(client, dataset_id)
         raise _not_found(dataset_id)
     what = f"the task of dataset '{dataset_id}'"
     if response.status_code != 200:

{tracebloc-1.2.74 → tracebloc-1.2.76}/tracebloc/convert/acceptance.py

@@ -21,6 +21,7 @@ from typing import Any, Iterator, Sequence
 
 from tracebloc.convert import outputs, training_versions
 from tracebloc.convert.interfaces import (
+    OWN_CODE_FAMILY,
     CheckFinding,
     ConverterWiringError,
     Family,
@@ -127,8 +128,13 @@ def upload_check(package: GeneratedPackage, written: WrittenPackage) -> CheckFin
     return _finding("upload", problems, "within the backend's caps, with a handler")
 
 
-def build_model(written: WrittenPackage, workdir: Path) -> tuple[Any, CheckFinding]:
-    """``MyModel()`` from the written package, seeded; ``None`` when it cannot be built."""
+def build_model(
+    written: WrittenPackage, workdir: Path, own_code: bool = False
+) -> tuple[Any, CheckFinding]:
+    """``MyModel()`` from the written package, seeded; ``None`` when it cannot be built.
+
+    The peer's ``own_code`` raising is its refusal, :func:`package.code_failure`.
+    """
     try:
         module = load_entry_module(written, workdir)
         if not callable(getattr(module, "MyModel", None)):
@@ -138,6 +144,8 @@ def build_model(written: WrittenPackage, workdir: Path) -> tuple[Any, CheckFindi
         with _seeded():
             model = module.MyModel()
     except Exception as error:  # noqa: BLE001 - the check reports, never raises
+        if own_code and not isinstance(error, ConverterWiringError):
+            raise package_module.code_failure(written, error) from error
         return None, CheckFinding(
             "build", False, f"MyModel() raised {_one_line(error)}"
         )
@@ -354,7 +362,8 @@ def findings(
 
     Refuses first, before anything is built, when a training library the
     package imports is installed here at another version than the training
-    images pin. Then: today's header check, the backend's upload checks,
+    images pin; it refuses the peer's own code, too, when ``MyModel()`` raises.
+    Then: today's header check, the backend's upload checks,
     ``MyModel()`` built, its parameter count, the shipped weights' strict load,
     the output against the original that ``family``'s ``build_original``
     builds (shape-only when it builds none), and the token ids for a package
@@ -366,7 +375,8 @@ def findings(
         upload_check(package, written),
     ]
     with scratch() as raw:
-        model, built = build_model(written, Path(raw))
+        own_code = package.family == OWN_CODE_FAMILY
+        model, built = build_model(written, Path(raw), own_code)
         found.append(built)
         if model is not None:
             found += model_findings(recognition, package, written, model, family)

{tracebloc-1.2.74 → tracebloc-1.2.76}/tracebloc/convert/families/hf/__init__.py

@@ -1,7 +1,9 @@
 """Hugging Face transformers: the use case names the task, any checkpoint fine-tunes.
 
 A folder is recognised by its ``config.json`` ``model_type``, read without
-running anything. A config with an ``auto_map`` ships its own model code, so
+running anything; a config saved without one names it through its
+``architectures``, which transformers' own mappings resolve. A config with an
+``auto_map`` ships its own model code, so
 the folder is the own-code converter's, not this family's. A sentence-transformers
 folder is the transformer its ``modules.json`` names. A folder saved for
 EvolutionaryScale's ``esm`` package is refused, naming ESM C's transformers checkpoint.
@@ -23,6 +25,8 @@ from typing import Any, Mapping
 
 from tracebloc.convert.families.hf._build import head_prefixes, load, model_source
 from tracebloc.convert.families.hf._build import write_weights
+from tracebloc.convert.families.hf._model_type import _AUTO, CONFIG_FILE, _mapping
+from tracebloc.convert.families.hf._model_type import _names, model_type_of
 from tracebloc.convert.families.vision import read_normalisation
 from tracebloc.convert.interfaces import ComparedOutput, ConversionInput, Proof
 from tracebloc.convert.interfaces import ConversionRefusedError, RefusalCause
@@ -33,7 +37,6 @@ from tracebloc.utils.constants import Framework, TaskCategory
 from tracebloc.validation.header_rules import NO_OUTPUT_CLASSES, SELF_SUPERVISED_NLP
 from tracebloc.validation.header_rules import SHAPE_VALUES
 
-CONFIG_FILE = "config.json"
 #: A sentence-transformers folder's module list.
 ST_MODULES = "modules.json"
 #: What transformers loads a folder's PyTorch weights from, shards included.
@@ -51,8 +54,6 @@ ESM_PACKAGE_WEIGHTS = "data/weights/esm*.pth"
 #: ESM C as transformers reads it (``model_type`` ``esmc``).
 ESMC_CHECKPOINTS = "biohub/ESMC-300M-hf, ESMC-600M-hf or ESMC-6B-hf"
 
-_AUTO = "transformers.models.auto"
-
 #: The Auto class each task is built with, and the mapping in
 #: ``transformers.models.auto.modeling_auto`` naming its class per
 #: ``model_type``. Earlier rows win as a checkpoint's declared head.
@@ -135,17 +136,6 @@ def _read_json(path: Path) -> Any:
         return None
 
 
-def _names(value: Any) -> tuple[str, ...]:
-    """A mapping's class names for one ``model_type``: one name or several."""
-    if isinstance(value, str):
-        return (value,)
-    return tuple(value) if isinstance(value, (tuple, list)) else ()
-
-
-def _mapping(name: str) -> Mapping[str, Any]:
-    return getattr(importlib.import_module(f"{_AUTO}.modeling_auto"), name, {})
-
-
 def _modality(model_type: str) -> str | None:
     """``"text"`` or ``"images"``, from transformers' tokenizer and image-processor
     mappings; ``None`` for a model with both or neither."""
@@ -350,9 +340,8 @@ class HuggingFaceFamily:
             return None
         folder, pooling = _sentence_transformer(path)
         config = _read_json(folder / CONFIG_FILE)
-        if not isinstance(config, dict) or not isinstance(
-            config.get("model_type"), str
-        ):
+        model_type = model_type_of(folder, config)
+        if model_type is None:
             _refuse_esm_package_layout(folder)
             return None
         if "auto_map" in config:
@@ -360,7 +349,10 @@ class HuggingFaceFamily:
         from tracebloc._framework_utils import require_module
 
         transformers = require_module("transformers", "converting a Hugging Face model")
-        model_type = config["model_type"]
+        read_from = CONFIG_FILE
+        if config.get("model_type") != model_type:
+            read_from = f"{CONFIG_FILE} architectures"
+            config = {**config, "model_type": model_type}
         known = importlib.import_module(f"{_AUTO}.configuration_auto")
         if model_type not in known.CONFIG_MAPPING_NAMES:
             raise ConversionRefusedError(
@@ -376,7 +368,10 @@ class HuggingFaceFamily:
         if pooling is not None:
             declared = TaskCategory.EMBEDDINGS
         label = architecture or model_type
-        values = {"entry_point": _sourced(label, CONFIG_FILE, weights)}
+        values = {
+            "entry_point": _sourced(label, CONFIG_FILE, weights),
+            "model_type": _sourced(model_type, read_from),
+        }
         names = _class_names(config)
         if names:
             values["id2label"] = _sourced(names, f"{CONFIG_FILE} id2label")

tracebloc-1.2.76/tracebloc/convert/families/hf/_model_type.py

@@ -0,0 +1,73 @@
+"""A Hugging Face folder's ``model_type``: its config's, or its architecture's.
+
+ProtBERT's config.json names ``BertForMaskedLM`` and no ``model_type``;
+transformers' own mappings give the model type of an architecture.
+"""
+
+from __future__ import annotations
+
+import importlib
+from pathlib import Path
+from typing import Any, Mapping
+
+from tracebloc.convert.interfaces import ConversionRefusedError, RefusalCause
+
+CONFIG_FILE = "config.json"
+_AUTO = "transformers.models.auto"
+
+
+def _names(value: Any) -> tuple[str, ...]:
+    """A mapping's class names for one ``model_type``: one name or several."""
+    if isinstance(value, str):
+        return (value,)
+    return tuple(value) if isinstance(value, (tuple, list)) else ()
+
+
+def _mapping(name: str) -> Mapping[str, Any]:
+    return getattr(importlib.import_module(f"{_AUTO}.modeling_auto"), name, {})
+
+
+def _architecture_model_type(folder: Path, architecture: str) -> str:
+    """The ``model_type`` transformers' mappings give ``architecture``; refused
+    when they give none, or several the class's own config does not settle."""
+    import transformers
+
+    modeling = importlib.import_module(f"{_AUTO}.modeling_auto")
+    found = {
+        model_type
+        for name in vars(modeling)
+        if name.endswith("_MAPPING_NAMES")
+        for model_type, classes in _mapping(name).items()
+        if architecture in _names(classes)
+    }
+    if len(found) > 1:
+        try:
+            own = getattr(transformers, architecture).config_class.model_type
+        except Exception:  # noqa: BLE001 - a class that cannot load settles nothing
+            own = None
+        found = {own} if own in found else found
+    if len(found) == 1:
+        return found.pop()
+    named = f"several, {', '.join(sorted(found))}" if found else "none"
+    raise ConversionRefusedError(
+        RefusalCause.NO_TASK_CLASS,
+        f"{folder.name}'s {CONFIG_FILE} declares no model_type, and transformers "
+        f"{transformers.__version__} gives its architecture {architecture} {named}; "
+        f"add the model_type it was saved with to {CONFIG_FILE}",
+    )
+
+
+def model_type_of(folder: Path, config: Any) -> str | None:
+    """The config's ``model_type``, or its architecture's; ``None`` when the
+    folder is not a transformers model or ships its own code."""
+    if not isinstance(config, dict):
+        return None
+    if isinstance(config.get("model_type"), str):
+        return config["model_type"]
+    architectures = _names(config.get("architectures"))
+    if "auto_map" in config or not architectures:
+        return None
+    from tracebloc._framework_utils import require_module
+
+    require_module("transformers", "converting a Hugging Face model")
+    return _architecture_model_type(folder, architectures[0])

{tracebloc-1.2.74 → tracebloc-1.2.76}/tracebloc/convert/interfaces.py

@@ -31,6 +31,9 @@ FAMILIES_PACKAGE = "tracebloc.convert.families"
 #: The module-level name each family module binds its family to.
 FAMILY_ATTRIBUTE = "FAMILY"
 
+#: The family every package built from the peer's own code records.
+OWN_CODE_FAMILY = "own_code"
+
 #: A family's ``name``: the stable id the report records.
 _FAMILY_NAME = re.compile(r"^[a-z][a-z0-9_]*$")
 
@@ -262,6 +265,8 @@ class RefusalCause(_StringEnum):
     BLOCKED_FAMILY = "blocked_family"
     #: Local library versions differ from the training image's.
     VERSIONS = "versions"
+    #: The model's own code raises when it is imported, built or read.
+    CODE_FAILS = "code_fails"
 
 
 class ConversionRefusedError(ModelValidationError):

{tracebloc-1.2.74 → tracebloc-1.2.76}/tracebloc/convert/owncode/__init__.py

@@ -27,6 +27,7 @@ from pathlib import Path
 from typing import Any, Iterator
 
 from tracebloc.convert.interfaces import (
+    OWN_CODE_FAMILY,
     ComparedOutput,
     ConversionInput,
     GeneratedPackage,
@@ -39,7 +40,7 @@ from tracebloc.convert.interfaces import (
 class OwnCode:
     """What runs when no family recognises the input."""
 
-    name = "own_code"
+    name = OWN_CODE_FAMILY
 
     def recognise(self, source: ConversionInput) -> Recognition | None:
         from tracebloc.convert.owncode import layer0, live, remote, repo

{tracebloc-1.2.74 → tracebloc-1.2.76}/tracebloc/convert/owncode/assemble.py

@@ -12,6 +12,7 @@ from pathlib import Path
 from typing import Any, Mapping
 
 from tracebloc.convert.interfaces import (
+    OWN_CODE_FAMILY,
     ComparedOutput,
     ConversionRefusedError,
     ConverterWiringError,
@@ -33,7 +34,7 @@ from tracebloc.convert.owncode.shake import flat_name, shake
 from tracebloc.utils.constants import TaskCategory
 
 #: The name every own-code package records as its family.
-FAMILY = "own_code"
+FAMILY = OWN_CODE_FAMILY
 
 #: The class the platform loads from the entry file.
 ENTRY_CLASS = "MyModel"

{tracebloc-1.2.74 → tracebloc-1.2.76}/tracebloc/convert/owncode/live.py

@@ -38,6 +38,7 @@ from tracebloc.convert.owncode.assemble import FAMILY
 from tracebloc.convert.owncode.model_class import ClassIndex
 from tracebloc.convert.owncode.repo import class_state
 from tracebloc.convert.owncode.source_tree import SourceTree
+from tracebloc.convert.training_versions import refuse_code_failure
 from tracebloc.utils.constants import Framework
 
 #: The file a notebook's captured code is shipped from, and named by in messages.
@@ -266,16 +267,28 @@ def recognise(source: ConversionInput) -> Recognition | None:
     obj = source.live_object
     if torch is None or not isinstance(obj, torch.nn.Module):
         return None
-    model, hyper, notes = _model_of(obj)
+    try:
+        model, hyper, notes = _model_of(obj)
+        weights = dict(model.state_dict())
+        remote_config = (
+            model.config.to_dict()
+            if type(model).__module__.startswith("transformers_modules.")
+            else None
+        )
+    except ConversionRefusedError:
+        raise
+    except Exception as error:
+        what = "reading the object passed to upload_model"
+        raise refuse_code_failure(what, error) from error
     cls = type(model)
     module = sys.modules.get(cls.__module__)
     file = getattr(module, "__file__", None)
     if file and installed(Path(file)):
         raise _refuse(f"is {cls.__module__}.{cls.__name__}, a library class")
-    weights = dict(model.state_dict())
-    if cls.__module__.startswith("transformers_modules.") and file:
-        config = model.config.to_dict()
-        found = remote.recognise_parts(source, Path(file).parent, config, weights, None)
+    if remote_config is not None and file:
+        found = remote.recognise_parts(
+            source, Path(file).parent, remote_config, weights, None
+        )
         state = {**found.state, "live_object": model, "proof": Proof.EXACT}
         return dataclasses.replace(found, state=state)
     if cls.__module__.split(".")[0] in LIBRARY_ROOTS:

{tracebloc-1.2.74 → tracebloc-1.2.76}/tracebloc/convert/package.py

@@ -29,6 +29,7 @@ from typing import Any, Callable, Mapping
 
 from tracebloc.upload.weights_parts import IN_PARTS_CAP_BYTES, SINGLE_REQUEST_CAP_BYTES
 from tracebloc.convert.interfaces import (
+    OWN_CODE_FAMILY,
     ConversionRefusedError,
     ConverterWiringError,
     GeneratedPackage,
@@ -36,6 +37,7 @@ from tracebloc.convert.interfaces import (
     RefusalCause,
     SourcedValue,
 )
+from tracebloc.convert.training_versions import refuse_code_failure
 from tracebloc.exceptions import ModelValidationError
 from tracebloc.validation.rewriter import ModelFileRewriter
 
@@ -362,6 +364,16 @@ def state_dict_shapes(written: WrittenPackage) -> dict[str, tuple[int, ...]]:
         return {key: tuple(value.shape) for key, value in model.state_dict().items()}
 
 
+def code_failure(written: WrittenPackage, error: Exception) -> ConversionRefusedError:
+    """The refusal for the peer's own code in ``written`` raising ``error`` when run."""
+    with tempfile.TemporaryDirectory(prefix="tracebloc_sources_") as raw:
+        sources = [
+            path.read_text(encoding="utf-8")
+            for path in python_sources(written.model_file, Path(raw))
+        ]
+    return refuse_code_failure("the converted model's code", error, sources)
+
+
 def derive_seed_excluded_prefixes(
     build_for_classes: Callable[[int, Path], GeneratedPackage],
     shapes: Callable[
@@ -371,7 +383,8 @@ def derive_seed_excluded_prefixes(
     """The head's prefixes: build with each of :data:`PROBE_CLASSES` and diff.
 
     ``build_for_classes(count, workdir)`` builds the package for ``count``
-    output classes, which for a family is its ``build`` with that count.
+    output classes, which for a family is its ``build`` with that count. The
+    peer's own code raising when it runs here is its :func:`code_failure`.
     """
     built = []
     for count in PROBE_CLASSES:
@@ -379,7 +392,15 @@ def derive_seed_excluded_prefixes(
             workdir, out = Path(raw) / "build", Path(raw) / "package"
             workdir.mkdir()
             package = build_for_classes(count, workdir)
-            built.append(shapes(write_package(package, out, "probe")))
+            written = write_package(package, out, "probe")
+            try:
+                built.append(shapes(written))
+            except (ConversionRefusedError, ConverterWiringError):
+                raise
+            except Exception as error:
+                if package.family != OWN_CODE_FAMILY:
+                    raise
+                raise code_failure(written, error) from error
     return head_prefixes(*built)
 
 

{tracebloc-1.2.74 → tracebloc-1.2.76}/tracebloc/convert/training_versions.py

@@ -25,6 +25,7 @@ from tracebloc.convert.interfaces import (
     ConverterWiringError,
     RefusalCause,
 )
+from tracebloc.utils.general_utils import format_exception
 
 #: The vendored copy of the training images' requirements.
 PINS_FILE = (
@@ -52,6 +53,8 @@ TRAINING_LIBRARIES: Mapping[str, tuple[str, ...]] = {
 TRAINING_EXTRA = "training"
 
 _PIN = re.compile(r"^\s*([A-Za-z0-9][A-Za-z0-9._-]*)\s*==\s*([^\s;#]+)")
+#: The ``(/path/to/file.py)`` an ImportError names: this machine's, not the model's.
+_SOURCE_FILE = re.compile(r" \((?:/|[A-Za-z]:\\)[^)]*\)")
 
 
 def read_pins(path: Path | None = None) -> dict[str, str]:
@@ -160,3 +163,28 @@ def refuse_other_versions(sources: Iterable[str]) -> CheckFinding:
         raise ConversionRefusedError(RefusalCause.VERSIONS, refusal_message(clauses))
     shown = ", ".join(libraries) or "no training library"
     return CheckFinding("versions", True, f"{shown} at the training images' versions")
+
+
+def refuse_code_failure(
+    what: str, error: BaseException, sources: Iterable[str] = ()
+) -> ConversionRefusedError:
+    """The refusal for the model's own code raising ``error`` while ``what`` ran.
+
+    ``sources`` are the model files run. When a training library they import is
+    installed here at another version than training's, that is the refusal.
+    """
+    libraries = imported_libraries(sources) or ("torch",)
+    clauses = version_mismatches(libraries)
+    if clauses:
+        return ConversionRefusedError(RefusalCause.VERSIONS, refusal_message(clauses))
+    pins = read_pins()
+    named = ", ".join(f"{name} {pinned_version(name, pins)}" for name in libraries)
+    detail = " ".join(_SOURCE_FILE.sub("", format_exception(error)).split())[:300]
+    advice = "fix the code so it runs under them"
+    if "transformers" in libraries:
+        advice += ", or bring a checkpoint transformers reads without its own code"
+    return ConversionRefusedError(
+        RefusalCause.CODE_FAILS,
+        f"{what} raised {detail}: the model's own code does not run under the "
+        f"training versions ({named}); {advice}",
+    )

{tracebloc-1.2.74 → tracebloc-1.2.76}/tracebloc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tracebloc
-Version: 1.2.74
+Version: 1.2.76
 Summary: Build AI with anyone. On data that can't move. SDK for the tracebloc collaborative AI workspace.
 Author-email: tracebloc <lukas@tracebloc.io>
 License-Expression: MIT

{tracebloc-1.2.74 → tracebloc-1.2.76}/tracebloc.egg-info/SOURCES.txt

@@ -52,6 +52,7 @@ tracebloc/convert/families/__init__.py
 tracebloc/convert/families/tabular.py
 tracebloc/convert/families/hf/__init__.py
 tracebloc/convert/families/hf/_build.py
+tracebloc/convert/families/hf/_model_type.py
 tracebloc/convert/families/vision/__init__.py
 tracebloc/convert/families/vision/_matching.py
 tracebloc/convert/licence/__init__.py