RadGraph-IT 1.0.0__py3-none-any.whl

radgraph_it-1.0.0.dist-info/METADATA

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: RadGraph-IT
+Version: 1.0.0
+Summary: RadGraph graph inference for Italian radiology reports, with output in the canonical RadGraph-XL format.
+Project-URL: Homepage, https://github.com/therabo/RadGraph-IT
+Project-URL: Repository, https://github.com/therabo/RadGraph-IT
+Project-URL: Issues, https://github.com/therabo/RadGraph-IT/issues
+Project-URL: Changelog, https://github.com/therabo/RadGraph-IT/blob/main/CHANGELOG.md
+Author: Daniel Rabottini, Edoardo Avenia, Rocco Angelella
+License-Expression: MIT
+License-File: LICENSE
+License-File: LICENSES/Third-Party.md
+Keywords: information-extraction,italian,nlp,radgraph,radiology
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: Italian
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: huggingface-hub>=0.23
+Requires-Dist: nltk>=3.8
+Requires-Dist: packaging>=23
+Requires-Dist: torch>=2.1
+Requires-Dist: transformers>=4.39
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pre-commit>=3.5; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff==0.16.0; extra == 'dev'
+Requires-Dist: safetensors>=0.4; extra == 'dev'
+Requires-Dist: twine>=5; extra == 'dev'
+Provides-Extra: safetensors
+Requires-Dist: safetensors>=0.4; extra == 'safetensors'
+Description-Content-Type: text/markdown
+
+# RadGraph-IT 🇮🇹
+
+**RadGraph** graph inference for **Italian** radiology reports, with output in the canonical
+**RadGraph-XL** format.
+
+`radgraphit` takes one or more Italian radiology reports, runs the Italian DyGIE v2 model
+(PyTorch: shared encoder, span extractor, NER head, and relation head), and returns the graph of
+entities and relations as the RadGraph-XL-compatible dictionary.
+
+- **Package / import / CLI name:** `radgraphit` · **Python:** `>= 3.10` · **Device:** CPU or CUDA
+- **Model:** downloaded automatically from pinned Hugging Face revisions on first use
+  (~445 MB / 424 MiB plus small tokenizer/config files, then cached)
+
+## Installation
+
+```bash
+pip install radgraphit
+```
+
+## Usage — Python API
+
+```python
+from radgraphit import RadGraphIT
+
+predictor = RadGraphIT()
+annotations = predictor.predict(
+    "Non si evidenziano segni di pneumotorace dopo la rimozione del drenaggio toracico."
+)
+```
+
+`predict` accepts a **string** or a **sequence of strings** and preserves order.
+`predictor(report)` is an alias for `predictor.predict(report)`:
+
+```python
+annotations = predictor(["referto 1", "referto 2"])  # batch, order preserved
+```
+
+## Usage — CLI
+
+```bash
+# report as an argument
+radgraphit predict "Non si evidenzia pneumotorace."
+
+# from a file (one report per line), or from stdin
+radgraphit predict --input-file reports.txt
+echo "Nessuna evidenza di pneumotorace." | radgraphit predict
+```
+
+The result is written as JSON to stdout.
+
+## Output
+
+For the input `["Non si evidenzia pneumotorace ..."]` the output has this shape (top-level keys
+`"0"`, `"1"`, … in input order):
+
+```python
+{
+    "0": {
+        "text": "<normalized tokens, space-separated>",
+        "entities": {
+            "1": {
+                "tokens": "<span tokens>",
+                "label": "Observation::definitely absent",
+                "start_ix": 3,
+                "end_ix": 3,
+                "relations": [["located_at", "2"]],
+            }
+        },
+        "data_source": None,
+        "data_split": "inference",
+    },
+    "1": {"...": "..."},
+}
+```
+
+- The indices (`start_ix`, `end_ix`) are **token-level, zero-based, and inclusive**.
+- Relations are directed *source → target* lists `[label, target_entity_id]`.
+- The output is deterministic: entities and relations are stably ordered.
+
+## Citation
+
+The output format and the serializer derive from the official **RadGraph / RadGraph-XL** package
+(see [`Third-Party`](LICENSES/Third-Party.md)). If you use this package, please cite
+both this work and the RadGraph-XL paper:
+
+```bibtex
+@software{radgraphit,
+    author = "Daniel Rabottini and Edoardo Avenia and Rocco Angelella",
+    title = "{RadGraph-IT}: {RadGraph} graph inference for {Italian} radiology reports",
+    year = "2026",
+    version = "1.0.0",
+    url = "https://github.com/therabo/RadGraph-IT",
+}
+```
+
+```bibtex
+@inproceedings{delbrouck-etal-2024-radgraph,
+    title = "{R}ad{G}raph-{XL}: A Large-Scale Expert-Annotated Dataset for Entity and Relation
+             Extraction from Radiology Reports",
+    author = "Delbrouck, Jean-Benoit and Chambon, Pierre and Chen, Zhihong and Varma, Maya and
+              Johnston, Andrew and Blankemeier, Louis and Van Veen, Dave and Bui, Tan and
+              Truong, Steven and Langlotz, Curtis",
+    booktitle = "Findings of the Association for Computational Linguistics ACL 2024",
+    year = "2024",
+    url = "https://aclanthology.org/2024.findings-acl.765",
+    pages = "12902--12915",
+}
+```
+
+## License
+
+See the [`MIT License`](LICENSE) and [`Third-Party`](LICENSES/Third-Party.md) notices.
+
+> **Not a medical device.** The output is an automatic extraction of entities and relations from
+> text and does not constitute a diagnosis, a report, or a clinical opinion.

radgraph_it-1.0.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+radgraphit/__init__.py,sha256=axB-_vOQ0oxpkLfKcm-zugE9EAno__Q2Cs1vYpDuGz4,1253
+radgraphit/api.py,sha256=gBSE9ghTwDGb_KZ9eMGQAMbEsjn_CIOkBKt1UqWByOg,6549
+radgraphit/cli.py,sha256=Q7Ifzji1ae9NplUwtGc-kvnL3HAA1DHBISFNGBueUzM,4784
+radgraphit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+radgraphit/artifacts/__init__.py,sha256=9s6PKiGZW26zn6F_BBJ_ApsV-XeP1KDrcjlnhKhBcrE,247
+radgraphit/artifacts/manifest.py,sha256=PGnZKb1f28dpvcRd8ssP516Ry5XCD1KNAjm-SySZfqE,12702
+radgraphit/artifacts/registry.py,sha256=4n6DHuoi3qDLiONQUVxVYqDpboF3k3_sEym6HxG554k,929
+radgraphit/artifacts/resolver.py,sha256=4AfDPUAEQOu13BLd8IS5rJ8XP90OXUiq9t_CD71C-so,8078
+radgraphit/core/__init__.py,sha256=spw93ti5KhNBlUCSKIjDK74nWhmTp7O3Z418DZAJb1Q,86
+radgraphit/core/errors.py,sha256=BJgE1FP2sVINBAw--0nvlqKntS5rLnLZTl8W5i75pHo,1577
+radgraphit/core/models.py,sha256=WlWLwzQeoSNasGzYH0BnvUsxtS3L3oWGSHUSjS_JhYA,3843
+radgraphit/inference/__init__.py,sha256=ZXwhdEOAJ-B1nH8ZGEzVOmJk3ocqWgQQllMqiogApXY,255
+radgraphit/inference/decoder.py,sha256=ls79WFJ4HQbh_FKHhDpFpvkQWk-Bi8Aal5GRrBssGBg,1689
+radgraphit/inference/service.py,sha256=xNpdpxip9BVGR-FxvXJ_cJu3f0F1JsInslnQahYkPes,3364
+radgraphit/inference/tokenizer.py,sha256=Er2ooK8jy-JqmDRfwIjknTc4lD8bmRwvgEqSH0R_IMg,2692
+radgraphit/inference/backends/__init__.py,sha256=fxImXnfQFeAaa8RuUueZslnHLgsdSC6OYyCdhHY6A0o,96
+radgraphit/inference/backends/base.py,sha256=W5noZOMATRabbKBHk3lLKlauLHVCJdCScIMBkYScXXA,590
+radgraphit/inference/backends/dygie_v2/__init__.py,sha256=EqFi85Wz4aajgDLRO85AGdVKKsca3yljeebTJ95bk9U,492
+radgraphit/inference/backends/dygie_v2/backend.py,sha256=ZvgJsIjJBKgnsEjWQVvw3XIbbTwuv82Y17kLdMpWDVY,1073
+radgraphit/inference/backends/dygie_v2/device.py,sha256=66TtM3sEbnLvTGJSPgYDLnd4M_mam-RB7R5f48L7Lzk,1917
+radgraphit/inference/backends/dygie_v2/feedforward.py,sha256=bNR5LM0MbOfyqa2eVSFbmOckdVDGgJbaRSFzBBYJwkk,797
+radgraphit/inference/backends/dygie_v2/loader.py,sha256=PHh6mB6NGDog7vPB7JMzMKX_ZwjwpDPLKd-SBPQTjLw,6847
+radgraphit/inference/backends/dygie_v2/model.py,sha256=JTLEORUALbn9sE33_pwgGki6K1VMezmadyAacgNeV-c,3689
+radgraphit/inference/backends/dygie_v2/ner_head.py,sha256=797nBLytn5VmwWK1EEDOMunl_TvWhqaq05SFNng1QF4,3082
+radgraphit/inference/backends/dygie_v2/pruner.py,sha256=nd7lH7d7Y82Sb2XtdG8sp9AwNV-Cy9pwYhPdJgpQ-DM,1022
+radgraphit/inference/backends/dygie_v2/relation_head.py,sha256=XD1es7h57Z4AEpSuMYMXVSlmwNKWsqiK8OD2Txc7apc,6449
+radgraphit/inference/backends/dygie_v2/span_extractor.py,sha256=ekB0BDtRlRzqmErM55UFPIBgqqXcaQk8s-0Rn8bubsY,2284
+radgraphit/inference/backends/dygie_v2/spans.py,sha256=7i5MnVC5UK9yf1WBUlMB7E_WxAy1Z2EG3iyCf5UwHBg,804
+radgraphit/inference/backends/dygie_v2/tokenizer_embedder.py,sha256=YQtTlIDNmMU6PjY8GQzz0DOygAU-cH_gkTUIt2iECbg,4948
+radgraphit/inference/backends/dygie_v2/transformer_block.py,sha256=yHoOcemeR9eDiExD7WlP-nTWX-geNcAxrVmnYgPvxkE,2272
+radgraphit/inference/backends/dygie_v2/vocab.py,sha256=xiHU0Tzij0fbDJUSp2ErB1n48pfFV9BWblGttR0ZpBY,5332
+radgraphit/serialization/__init__.py,sha256=QCd8PjDTXaeO9ayJHNiE4CiSYPEFDug8hN7kR7ZqKOk,364
+radgraphit/serialization/radgraph_xl.py,sha256=g3E7368G_-0Ue-N7Xad_e0CyundjDPDuQ51a47402ck,5965
+radgraph_it-1.0.0.dist-info/METADATA,sha256=Zl4fb4tByGUgIfNgcJW79i02f_OYjIYl2uDsc6-wevs,5682
+radgraph_it-1.0.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+radgraph_it-1.0.0.dist-info/entry_points.txt,sha256=xxBQ-WlmPXumfg3tNJNKk7VIpamQX4v8UmIpmFnYNxQ,51
+radgraph_it-1.0.0.dist-info/licenses/LICENSE,sha256=5KhNHP1ryGIP_aYYWPUNBQ0PUnLPKGznCAb-95svTbc,1185
+radgraph_it-1.0.0.dist-info/licenses/LICENSES/Third-Party.md,sha256=k63tiwV1ZJTDPC4cX20jEBjbzV_1xDjIj_svU16XTJU,2019
+radgraph_it-1.0.0.dist-info/RECORD,,

radgraph_it-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

radgraph_it-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+radgraphit = radgraphit.cli:main

radgraph_it-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2026 Daniel Rabottini (therabo)
+Copyright (c) 2026 Edoardo Avenia (edoardoavenia)
+Copyright (c) 2026 Rocco Angelella (roccoangelella)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

radgraph_it-1.0.0.dist-info/licenses/LICENSES/Third-Party.md

@@ -0,0 +1,41 @@
+# Third-Party
+
+This file collects provenance and attributions. It does **not** declare weights, datasets, or
+clinical texts redistributable, and it does **not** automatically copy any third-party license. The
+package code itself is licensed under MIT (see the root `LICENSE` file); this file concerns the
+third-party components it builds on.
+
+## RadGraph-XL output format and serializer
+
+The output dictionary and the serialization logic (`postprocess_reports` / `get_entity`) derive from
+the official **RadGraph / RadGraph-XL** package from Stanford AIMI / StanfordMIMI.
+
+- Upstream repository: `radgraph` package (Stanford), distributed under the MIT license.
+
+Citation:
+
+> Delbrouck et al. "RadGraph-XL: A Large-Scale Expert-Annotated Dataset for Entity and Relation
+> Extraction from Radiology Reports." Findings of the ACL 2024, pp. 12902–12915.
+> https://aclanthology.org/2024.findings-acl.765
+
+## Inference backend (`dygie_v2`)
+
+An inference-only PyTorch port of the Italian v2 model (internal project "RadGraph-XL-IT",
+`training_v2`), which is itself a pure-PyTorch reimplementation of the DyGIE++ architecture
+(NER + relations) without AllenNLP.
+
+- DyGIE / DyGIE++ architecture: Wadden et al., "Entity, Relation, and Event Extraction with
+  Contextualized Span Representations", EMNLP 2019.
+- Pre-trained encoder: fetched at runtime from the Hugging Face Hub (e.g. `IVN-RIN/medBIT-r3-plus`);
+  subject to the license of its own repository on the Hub. Not redistributed by this package.
+
+## Model, weights, and data
+
+The model weights, the datasets, and any clinical text are **not** included in this repository or in
+the wheel/sdist, and are not declared redistributable. The model bundle is hosted separately on the
+Hugging Face Hub and is subject to the licenses/terms declared in that repository.
+
+## Runtime dependencies
+
+`torch`, `transformers`, `nltk`, `huggingface_hub` are subject to their respective licenses
+(BSD-3-Clause, Apache-2.0, Apache-2.0, Apache-2.0 respectively, unless changed upstream).

radgraphit/__init__.py

@@ -0,0 +1,47 @@
+"""radgraphit — RadGraph-XL inference for Italian radiology reports.
+
+Public API::
+
+    from radgraphit import RadGraphIT
+
+Importing this package has no side effects: no network I/O, no model download, no logging to
+stdout, and no torch import. Everything model-related is loaded lazily on first use.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from .api import RadGraphIT
+from .core.errors import (
+    BackendError,
+    CheckpointError,
+    DeviceError,
+    InvalidReportError,
+    ManifestError,
+    ModelConfigurationError,
+    ModelNotConfiguredError,
+    ModelNotFoundError,
+    RadGraphITError,
+)
+
+# A library must not configure logging handlers for the application; attach a NullHandler so that
+# emitting logs never prints a "No handlers could be found" warning if the app hasn't configured
+# logging (see https://docs.python.org/3/howto/logging.html#library-config).
+logging.getLogger("radgraphit").addHandler(logging.NullHandler())
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "BackendError",
+    "CheckpointError",
+    "DeviceError",
+    "InvalidReportError",
+    "ManifestError",
+    "ModelConfigurationError",
+    "ModelNotConfiguredError",
+    "ModelNotFoundError",
+    "RadGraphIT",
+    "RadGraphITError",
+    "__version__",
+]

radgraphit/api.py

@@ -0,0 +1,168 @@
+"""The public facade: :class:`RadGraphIT`.
+
+Small, typed, stable, and free of import-time side effects. Constructing a ``RadGraphIT`` performs
+no network I/O; the model artifact is resolved and loaded lazily on first ``predict`` (or an
+explicit :meth:`load`). Importing this module does not import torch or huggingface_hub.
+
+Usage::
+
+    from radgraphit import RadGraphIT
+
+    predictor = RadGraphIT.from_local("/path/to/model", device="auto")
+    annotations = predictor.predict([
+        "Non si evidenziano segni di pneumotorace dopo la rimozione del drenaggio toracico."
+    ])
+
+The standard Hub-backed path is::
+
+    predictor = RadGraphIT(device="auto")  # or RadGraphIT.from_pretrained(...)
+    annotations = predictor.predict("Nessuna evidenza di pneumotorace.")
+"""
+
+from __future__ import annotations
+
+import functools
+import logging
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING
+
+from .artifacts import registry
+from .core.errors import BackendError
+from .core.models import InferenceBackend, ReportPrediction
+from .inference.service import InferenceService
+
+if TYPE_CHECKING:
+    from .artifacts.resolver import ResolvedModel
+
+logger = logging.getLogger("radgraphit")
+
+
+def _resolve_pretrained(
+    model_id: str, revision: str, cache_dir: str | None, local_files_only: bool
+) -> ResolvedModel:
+    # Imported lazily so `import radgraphit` never pulls in huggingface_hub.
+    from .artifacts import resolver
+
+    return resolver.resolve_pretrained(
+        model_id, revision=revision, cache_dir=cache_dir, local_files_only=local_files_only
+    )
+
+
+def _resolve_local(path: str) -> ResolvedModel:
+    from .artifacts import resolver
+
+    return resolver.resolve_local(path)
+
+
+def _build_backend(resolved: ResolvedModel, device: str) -> InferenceBackend:
+    backend_name = resolved.manifest.backend
+    if backend_name == "dygie_v2":
+        # Imported lazily so torch/transformers load only when a model is actually built.
+        from .inference.backends.dygie_v2 import load_backend
+
+        return load_backend(
+            config_path=resolved.config_path,
+            vocab_path=resolved.vocab_path,
+            weights_path=resolved.weights_path,
+            device=device,
+            encoder_revision=resolved.manifest.encoder_revision,
+        )
+    raise BackendError(
+        f"Model manifest requests backend {backend_name!r}, which this version of radgraphit does "
+        f"not support (supported: {sorted(registry.SUPPORTED_BACKENDS)})."
+    )
+
+
+class RadGraphIT:
+    """Predict RadGraph-XL graphs for Italian radiology reports."""
+
+    def __init__(
+        self,
+        *,
+        device: str = "auto",
+        model_id: str | None = None,
+        revision: str | None = None,
+        cache_dir: str | None = None,
+        local_files_only: bool = False,
+    ):
+        """Configure a predictor backed by the default (Hugging Face Hub) model.
+
+        No network I/O happens here — the artifact is downloaded and the model built lazily on the
+        first :meth:`predict`. Passing ``model_id``/``revision`` overrides the registry defaults.
+        The default model is a public, ungated Hub repository, so no authentication is required.
+        """
+        self._device = device
+        self._service: InferenceService | None = None
+        resolved_model_id = model_id if model_id is not None else registry.DEFAULT_MODEL_ID
+        resolved_revision = revision if revision is not None else registry.DEFAULT_REVISION
+        self._resolve: Callable[[], ResolvedModel] = functools.partial(
+            _resolve_pretrained, resolved_model_id, resolved_revision, cache_dir, local_files_only
+        )
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        model_id: str = registry.DEFAULT_MODEL_ID,
+        *,
+        revision: str = registry.DEFAULT_REVISION,
+        cache_dir: str | None = None,
+        device: str = "auto",
+        local_files_only: bool = False,
+    ) -> RadGraphIT:
+        """Standard path: resolve the model from the Hugging Face Hub (lazily, on first predict).
+
+        ``revision`` is pinned explicitly (commit sha or tag). The default model is a public,
+        ungated Hub repository, so no authentication is required.
+        """
+        return cls(
+            device=device,
+            model_id=model_id,
+            revision=revision,
+            cache_dir=cache_dir,
+            local_files_only=local_files_only,
+        )
+
+    @classmethod
+    def from_local(cls, path: str, *, device: str = "auto") -> RadGraphIT:
+        """Development / offline path: load a manifest-verified bundle from a local directory."""
+        instance = cls(device=device)
+        instance._resolve = functools.partial(_resolve_local, path)
+        return instance
+
+    @classmethod
+    def from_service(cls, service: InferenceService, *, device: str = "auto") -> RadGraphIT:
+        """Advanced/testing: build a predictor around a pre-constructed service (e.g. a custom or
+        fake backend). Skips all artifact resolution and loading."""
+        instance = cls(device=device)
+        instance._service = service
+        return instance
+
+    def load(self) -> RadGraphIT:
+        """Eagerly resolve and load the model. Returns ``self`` for chaining. Optional — the model
+        is otherwise loaded on first :meth:`predict`."""
+        self._ensure_loaded()
+        return self
+
+    def _ensure_loaded(self) -> InferenceService:
+        if self._service is None:
+            resolved = self._resolve()
+            backend = _build_backend(resolved, self._device)
+            self._service = InferenceService(backend)
+            logger.debug("RadGraphIT model loaded (backend=%s)", resolved.manifest.backend)
+        return self._service
+
+    def predict(self, reports: str | Sequence[str]) -> dict[str, object]:
+        """Annotate one report (``str``) or several (``Sequence[str]``).
+
+        Returns the canonical RadGraph-XL dictionary, keyed by input order (``"0"``, ``"1"``, …).
+        See the README for the exact output shape.
+        """
+        return self._ensure_loaded().predict(reports)
+
+    def predict_graphs(self, reports: str | Sequence[str]) -> list[ReportPrediction]:
+        """Advanced: return the typed internal graphs instead of the RadGraph-XL dict."""
+        return self._ensure_loaded().predict_graphs(reports)
+
+    def __call__(self, reports: str | Sequence[str]) -> dict[str, object]:
+        """Alias for :meth:`predict`, for compatibility with the upstream callable interface."""
+        return self.predict(reports)

radgraphit/artifacts/__init__.py

@@ -0,0 +1,5 @@
+"""Model artifact handling: the default-location registry, the manifest, and the resolver.
+
+Importing this package pulls in ``huggingface_hub`` (a lightweight, torch-free dependency) but
+never torch. It performs no network I/O at import time.
+"""