euler-loading 2.25.0__tar.gz → 2.28.0__tar.gz

{euler_loading-2.25.0 → euler_loading-2.28.0}/.gitignore

@@ -42,3 +42,8 @@ TASK.md
 
 # uv
 uv.lock
+
+# Stray npm lockfile. Nothing in this package is built with npm, and worktree
+# tooling rewrites its "name" field to the branch directory on every branch,
+# so tracking it produced a merge conflict on every quick-merge.
+package-lock.json

euler_loading-2.28.0/CHANGELOG.md

@@ -0,0 +1,58 @@
+# Changelog
+
+## 2.27.0 (unreleased)
+
+- Add a dry-run command: `euler-loading <path>` (also `python -m
+  euler_loading <path>`) walks the ds-crawler artifact sets at or below one
+  folder, resolves the loader each dataset head declares in
+  `addons.euler_loading`, decodes a sample of the indexed files with it, and
+  reports shapes, dtypes and value ranges. Directories and `.zip` archives
+  are treated alike, nothing is written, and the exit status is non-zero when
+  a modality fails to resolve or decode. `euler_loading.dry_run.dry_run()`
+  exposes the same report to Python.
+- `resolve_loader_module` and `resolve_writer_module` take a
+  `variant="gpu"|"cpu"` keyword, so the CPU modules can be resolved through
+  the same contract pathway as the torch ones. This is what the dry run's
+  `--cpu` uses to check archives on a torch-free install.
+
+## 2.26.0
+
+- Add `read_extrinsics` to the Synscapes loaders, building a 4x4 rigid
+  transform from the six `camera.extrinsic` scalars. `transform_direction`
+  and `camera_axes` select the pose, its inverse, and vehicle or optical
+  camera axes; the assumed `Rz(yaw) @ Ry(pitch) @ Rx(roll)` order is recorded
+  in the modality metadata because the dataset does not document it.
+- Add Synscapes writers for every modality, making the loader a
+  `DenseDepthCodec`. Depth writes a float32 EXR `Z` channel and needs a
+  filesystem path; the intrinsics and extrinsics writers merge into a single
+  `meta/<id>.json`, replacing it in one step and keeping its permissions,
+  symlink and unmodelled fields rather than truncating it in place.
+- `sky_mask` now honours `meta['sky_class_id']`, or the same key in per-file
+  attributes, instead of hardcoding Cityscapes ID 23, so a dataset that
+  relabels sky round-trips through `write_sky_mask`.
+- Accept the plural `camera.intrinsics` / `camera.extrinsics` spellings and
+  report missing camera fields by name instead of raising `KeyError`.
+
+## 2.24.0 (unreleased)
+
+Add source-backed capture, strict per-output writers, explicit NPY/PNG encoding, typed calibration views and replay. Consolidate pinhole geometry and correct legacy skew scaling.
+
+
+## 2.23.0 (source changes; not published)
+
+- Reject wrapped decoders during dataset export by checking actual built-in
+  function identity. Ordinary callable loading remains supported.
+- Apply boolean thresholds before Pillow dtype conversion, and permit exact
+  int32/int64 crop and identity-resize plans while refusing float32 resampling.
+- Add `SamplePreprocessor.export_descriptor`, `MultiModalDataset.export_transform_plan`,
+  `SerializableTransform`, and `resolve_transform_descriptor`, paired with contract 0.4.0.
+- Freeze profiles, qualified source/calibration bindings, field policies, operation
+  order, and installed CPU backend versions. Infer output profiles and virtual
+  calibration geometry without materialization claims.
+- Add explicit Torch/Pillow execution, corrected pinhole skew in the opt-in path,
+  validity-aware depth policy, source immutability, and worker validator registration.
+- Cover five-field round trips, projected geometry, ambiguous bindings, unsupported
+  semantics, backend choices, schemas, and spawned workers in synthetic tests.
+
+Legacy preprocessing and writer behavior remain unchanged. Execution receipts,
+materialized metadata propagation, producer wiring, and GT replay are later work.

{euler_loading-2.25.0 → euler_loading-2.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: euler-loading
-Version: 2.25.0
+Version: 2.28.0
 Summary: Multi-modal PyTorch dataloader using ds-crawler indices
 Project-URL: Homepage, https://github.com/d-rothen/euler-loading
 Project-URL: Repository, https://github.com/d-rothen/euler-loading
@@ -174,6 +174,36 @@ when you want the CPU variant or a custom callable. See
 [Automatic loader resolution](docs/loaders.md#automatic-loader-resolution) for
 the full contract and writer rules.
 
+## Checking a dataset
+
+Before any of that runs, point the bundled command at a folder to see what
+euler-loading would make of it:
+
+```bash
+euler-loading /data/vkitti2
+```
+
+For every ds-crawler artifact set below that path it resolves the loader the
+dataset declares, decodes a sample of the indexed files with it, and prints
+the shape, dtype and value range that came back:
+
+```text
+vkitti_2.0.3_rgb  [ok]
+  path      /data/vkitti2/vkitti_2.0.3_rgb
+  contract  vkitti2_rgb, "Virtual KITTI 2 RGB", modality key: rgb
+  loader    vkitti2.rgb -> euler_loading.loaders.gpu.vkitti2.rgb
+  index     21260 files; available splits: train, val
+  decoded   1/1
+    Scene01/clone/frames/rgb/Camera_0/rgb_00000.jpg  ->  Tensor (3, 375, 1242) float32 in [0, 1]  (11.4 ms)
+```
+
+Nothing is written, directories and `.zip` archives are treated alike, and the
+exit status is non-zero if any modality failed to resolve or decode — so it
+also works as a CI step. `--all` decodes every file instead of a sample,
+`--cpu` checks the NumPy loaders on a torch-free install, and `--json` prints
+the same report for a machine. See
+[Dry-running loaders](docs/loaders.md#dry-running-loaders).
+
 ## What you get
 
 | | |
@@ -186,6 +216,7 @@ the full contract and writer rules.
 | **Loader resolution** | Loaders and writers resolve from the `dataset-head.json` `addons.euler_loading` contract, so datasets describe how to read themselves. |
 | **Writing back** | Resolved writers put inference outputs back in dataset-native formats, re-indexable with matching IDs. |
 | **Spatial preprocessing** | `SamplePreprocessor` resizes and crops consistently across images, depth, masks, ray maps *and* intrinsics. |
+| **Dry runs** | `euler-loading <folder>` resolves and exercises every loader a dataset declares, without writing anything. |
 
 ## Built-in loaders
 

{euler_loading-2.25.0 → euler_loading-2.28.0}/README.md

@@ -135,6 +135,36 @@ when you want the CPU variant or a custom callable. See
 [Automatic loader resolution](docs/loaders.md#automatic-loader-resolution) for
 the full contract and writer rules.
 
+## Checking a dataset
+
+Before any of that runs, point the bundled command at a folder to see what
+euler-loading would make of it:
+
+```bash
+euler-loading /data/vkitti2
+```
+
+For every ds-crawler artifact set below that path it resolves the loader the
+dataset declares, decodes a sample of the indexed files with it, and prints
+the shape, dtype and value range that came back:
+
+```text
+vkitti_2.0.3_rgb  [ok]
+  path      /data/vkitti2/vkitti_2.0.3_rgb
+  contract  vkitti2_rgb, "Virtual KITTI 2 RGB", modality key: rgb
+  loader    vkitti2.rgb -> euler_loading.loaders.gpu.vkitti2.rgb
+  index     21260 files; available splits: train, val
+  decoded   1/1
+    Scene01/clone/frames/rgb/Camera_0/rgb_00000.jpg  ->  Tensor (3, 375, 1242) float32 in [0, 1]  (11.4 ms)
+```
+
+Nothing is written, directories and `.zip` archives are treated alike, and the
+exit status is non-zero if any modality failed to resolve or decode — so it
+also works as a CI step. `--all` decodes every file instead of a sample,
+`--cpu` checks the NumPy loaders on a torch-free install, and `--json` prints
+the same report for a machine. See
+[Dry-running loaders](docs/loaders.md#dry-running-loaders).
+
 ## What you get
 
 | | |
@@ -147,6 +177,7 @@ the full contract and writer rules.
 | **Loader resolution** | Loaders and writers resolve from the `dataset-head.json` `addons.euler_loading` contract, so datasets describe how to read themselves. |
 | **Writing back** | Resolved writers put inference outputs back in dataset-native formats, re-indexable with matching IDs. |
 | **Spatial preprocessing** | `SamplePreprocessor` resizes and crops consistently across images, depth, masks, ray maps *and* intrinsics. |
+| **Dry runs** | `euler-loading <folder>` resolves and exercises every loader a dataset declares, without writing anything. |
 
 ## Built-in loaders
 

{euler_loading-2.25.0 → euler_loading-2.28.0}/docs/README.md

@@ -3,7 +3,7 @@
 | Guide | Covers |
 |---|---|
 | [Dataset & modalities](dataset.md) | `Modality` and `MultiModalDataset` reference, the sample dict, hierarchical modalities, splits, scoped metadata, zip archives, layout-aware loading |
-| [Loaders & writers](loaders.md) | The loader contract, per-file attributes, automatic resolution, protocols, and the full built-in loader inventory |
+| [Loaders & writers](loaders.md) | The loader contract, per-file attributes, automatic resolution, the `euler-loading` dry run, protocols, and the full built-in loader inventory |
 | [Preprocessing & transforms](preprocessing.md) | Cross-modal transforms, `SamplePreprocessor`, field kinds, calibration-aware resize and crop |
 | [Writing outputs](writing.md) | Writing predictions back in dataset-native formats and re-indexing them |
 

{euler_loading-2.25.0 → euler_loading-2.28.0}/docs/loaders.md

@@ -7,6 +7,7 @@ that file means.
 - [The contract](#the-contract)
 - [Per-file attributes](#per-file-attributes)
 - [Automatic loader resolution](#automatic-loader-resolution)
+- [Dry-running loaders](#dry-running-loaders)
 - [Loader protocols](#loader-protocols)
 - [Built-in loaders](#built-in-loaders)
 
@@ -129,6 +130,102 @@ Writers resolve from the same `addons.euler_loading` entry, in this order:
 2. for `function: "read_<suffix>"`, `write_<suffix>`,
 3. `write_<function>`.
 
+## Dry-running loaders
+
+Resolution only pays off if the loader a dataset names can really read its
+files. Point the bundled command at a path to find out, before a training run
+depends on it:
+
+```bash
+euler-loading /data/vkitti2
+python -m euler_loading /data/vkitti2   # same thing, no console script needed
+```
+
+It takes one path — a modality root, a `.zip` archive, or a folder holding
+several of them — and for every ds-crawler artifact set below it:
+
+1. loads the index, or a named split,
+2. resolves the loader its `addons.euler_loading` entry declares,
+3. decodes a sample of the indexed files with that loader,
+4. reports the shape, dtype and value range of what came back.
+
+Nothing is written and no dataset is constructed. A modality that cannot be
+read is reported, not raised, so one broken archive does not hide the rest.
+
+```text
+euler-loading dry-run: /data/vkitti2
+loader variant: gpu (torch tensors)
+
+vkitti_2.0.3_rgb  [ok]
+  path      /data/vkitti2/vkitti_2.0.3_rgb
+  contract  vkitti2_rgb, "Virtual KITTI 2 RGB", modality key: rgb
+  loader    vkitti2.rgb -> euler_loading.loaders.gpu.vkitti2.rgb
+  writer    write_rgb
+  index     21260 files; available splits: train, val
+  decoded   1/1
+    Scene01/clone/frames/rgb/Camera_0/rgb_00000.jpg  ->  Tensor (3, 375, 1242) float32 in [0, 1]  (11.4 ms)
+
+vkitti_2.0.3_textgt  [ok]
+  path      /data/vkitti2/vkitti_2.0.3_textgt
+  contract  vkitti2_intrinsics, "Virtual KITTI 2 intrinsics", modality key: camera_intrinsics
+  loader    vkitti2.read_intrinsics -> euler_loading.loaders.gpu.vkitti2.read_intrinsics (hierarchical)
+  writer    write_intrinsics
+  index     50 files
+  decoded   1/1
+    Scene01/clone/intrinsic.txt  ->  Tensor (3, 3) float32 in [0, 725]  (0.6 ms)
+
+2 modalities checked: 2 ok, 0 failed; 2/2 files decoded
+```
+
+The exit status is 0 when every modality resolved a loader and decoded every
+file it was asked to, and 1 otherwise, so the command works as a CI step or a
+job prologue.
+
+| Flag | Effect |
+|---|---|
+| `-n, --samples N` | Files to decode per modality, spread evenly across the index (default 1). `0` resolves loaders without decoding anything. |
+| `--all` | Decode every indexed file. Slow, but checks the whole archive. |
+| `--split NAME` | Dry-run a named ds-crawler split instead of the canonical index. |
+| `--scope SCOPE` | Read `.ds_crawler/SCOPE/` only, instead of every artifact set a root carries. |
+| `--cpu` | Resolve the NumPy loaders instead of the torch ones. Works on an install without PyTorch. |
+| `--max-depth N` | Directory levels below the path to search for dataset roots (default 3). |
+| `--json` | Print the report as JSON instead of text. |
+| `-v, --verbose` | Log debug output, including a traceback for every failed load. |
+
+The path takes the same inline selectors as `Modality`, so
+`euler-loading /data/muses.zip:train#scope=rgb` checks one split of one scope.
+
+Discovery stops at the first dataset root down each branch: a directory
+carrying its own `.ds_crawler/` is checked, never descended into, so a
+dataset's own scene directories are never walked. A root with several
+metadata scopes contributes one entry per scope, labelled with the selector
+that addresses it.
+
+### Reading the report
+
+| Line | What it is telling you |
+|---|---|
+| `error loader: ... no 'addons.euler_loading' entry` | the dataset head declares no loader, so only an explicit `Modality(..., loader=...)` can read it |
+| `loader vkitti2.rgb (unresolved)` plus an `error` | the contract names a loader that is unknown, misspelled, or needs a dependency this install lacks — `--cpu` resolves the torch-free variant |
+| `decoded 0/2` with per-file `FAILED` | the files are indexed and present, but the declared loader cannot decode them |
+| `(hierarchical)` after the loader | the declared function reads per-scene data; pass that modality as `hierarchical_modalities`, not `modalities` |
+| `error index: ...` | ds-crawler could not produce an index — a missing split, an unreadable archive, or a dataset head the contract rejects |
+| a warning about shared file IDs | the modalities below the path have no file ID in common, so they cannot be intersected into one `MultiModalDataset` |
+
+The same report is available as an API, which is what the command is a thin
+shell around:
+
+```python
+from euler_loading.dry_run import dry_run
+
+report = dry_run("/data/vkitti2", samples=3)
+if not report.ok:
+    for modality in report.modalities:
+        print(modality.label, modality.errors)
+
+report.to_dict()   # the same structure --json prints
+```
+
 ## Loader protocols
 
 `DenseDepthLoader` is a `runtime_checkable` Protocol defining the loader
@@ -193,8 +290,26 @@ Writers exist for every modality above.
 | `depth` | 1HW / HW | float32 | `img/depth/<id>.exr`, `Z` channel, planar depth in metres |
 | `class_segmentation` | 1HW / HW | int64 | `img/class/<id>.png`, original Cityscapes label IDs |
 | `instance_segmentation` | 1HW / HW | int64 | `img/instance/<id>.png`, decoded as `R + 256 * G + 65536 * B` |
-| `sky_mask` | 1HW / HW | bool | Sky label ID `23` in `img/class/<id>.png` |
+| `sky_mask` | 1HW / HW | bool | Sky label in `img/class/<id>.png`; ID `23` by default, or `meta['sky_class_id']` |
 | `read_intrinsics` | 3×3 | float32 | `camera.intrinsic` from `meta/<id>.json`: `fx`, `fy`, `u0`, `v0` |
+| `read_extrinsics` | 4×4 | float32 | `camera.extrinsic` from `meta/<id>.json`: `x`, `y`, `z`, `pitch`, `roll`, `yaw` |
+
+Writers exist for every modality above. `write_depth` needs a filesystem path
+because OpenEXR cannot write to a stream; dataset writers hand it a temporary
+file automatically, so zip outputs work unchanged. `write_sky_mask` emits a
+class image labelling sky with `meta['sky_class_id']`, default 23, and
+`write_intrinsics` and `write_extrinsics` merge into one `meta/<id>.json`
+rather than overwriting each other or the file's `scene` and `instance`
+blocks.
+
+That merge reads the file back, so it applies to filesystem destinations and
+replaces the file atomically. A zip destination is handed a fresh stream per
+modality instead, so writing both camera modalities into the **same** archive
+produces two entries with the same name, of which only the last is
+retrievable — give each modality its own output writer. Because the merge
+keeps fields it does not model, writing a rescaled matrix without passing
+`meta['resx']`/`['resy']` leaves the previous resolution in place; supply them
+whenever the matrix no longer matches the recorded resolution.
 
 Formats follow the [Synscapes dataset reference](https://synscapes.on.liu.se/features.html)
 and [FoggySynscapes EXR reader](https://github.com/MartinHahner/FoggySynscapes/blob/main/source/Depth_processing/exr_to_mat.py).
@@ -202,14 +317,14 @@ Depth values are already in metres, so they are returned unchanged, including
 non-finite values. Semantic labels retain the original IDs, including void
 labels, without remapping to training IDs.
 
-EXR loading needs the optional OpenEXR dependency:
+EXR depth loading and writing need the optional OpenEXR dependency:
 
 ```bash
 pip install "euler-loading[gpu,synscapes]"  # omit gpu for NumPy-only use
 ```
 
-RGB, segmentation and intrinsics work without OpenEXR. All six functions
-accept paths and binary streams. Intrinsics are stored in per-image files,
+RGB, segmentation, intrinsics and extrinsics work without OpenEXR; only depth
+loading and writing need it. All readers accept paths and binary streams. Intrinsics are stored in per-image files,
 so the native `meta` directory is a regular modality:
 
 ```python
@@ -224,6 +339,37 @@ dataset = MultiModalDataset(modalities={
 })
 ```
 
+#### Extrinsics conventions
+
+Synscapes records the camera mount as six scalars — `x`, `y`, `z` in metres and
+`pitch`, `roll`, `yaw` in radians — in the ego-vehicle frame, which the dataset
+defines as x forward, y left, z up. `read_extrinsics` composes them into a
+rigid 4×4 matrix, by default the camera's pose on the vehicle
+(`X_ego = T @ X_camera`). Two keys, taken from per-file `attributes` first and
+then from `meta`, select the other useful conventions:
+
+| Key | Values | Meaning |
+|---|---|---|
+| `transform_direction` | `camera_to_ego` (default), `ego_to_camera` | Direction of the returned transform |
+| `camera_axes` | `vehicle` (default), `optical` | Camera axes: vehicle-aligned, or x right / y down / z forward |
+
+Combine `ego_to_camera` with `optical` to project ego-frame points — such as
+the 3D bounding boxes in the instance metadata — through `read_intrinsics`:
+
+```python
+T = synscapes.read_extrinsics(
+    "/data/Synscapes/meta/1.json",
+    {"transform_direction": "ego_to_camera", "camera_axes": "optical"},
+)
+```
+
+The dataset documents the six fields and the ego frame but not the order in
+which the angles compose, so the loaders apply the usual automotive
+`Rz(yaw) @ Ry(pitch) @ Rx(roll)` and record that in `loaders.json` under the
+modality's `rotation_order`. The values are constant across the released
+dataset. `write_extrinsics` reads the same two keys, so a matrix loaded with
+one set of options writes back unchanged with the same options.
+
 Automatic resolution uses `loader="synscapes"` in the dataset contract.
 Intrinsics describe the metadata's image resolution (native 1440×720).
 When using `img/rgb-2k` at 2048×1024, scale the camera matrix with

euler_loading-2.28.0/euler_loading/__main__.py

@@ -0,0 +1,10 @@
+"""``python -m euler_loading`` — dry-run the loaders a dataset declares."""
+
+from __future__ import annotations
+
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

{euler_loading-2.25.0 → euler_loading-2.28.0}/euler_loading/_ds_crawler_utils.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import io
+import zipfile
 from collections.abc import Mapping
 from pathlib import Path
 from typing import Any
@@ -22,6 +24,22 @@ from ds_crawler.zip_utils import (
 )
 
 
+def read_zip_member(
+    archive: zipfile.ZipFile,
+    prefix: str,
+    relative_path: str,
+) -> io.BytesIO:
+    """Read one member of a zip-backed modality into an in-memory buffer.
+
+    The buffer carries the modality-relative path as its ``name`` so loaders
+    that branch on the file extension behave the same as for a filesystem
+    path.
+    """
+    buffer = io.BytesIO(archive.read(prefix + relative_path))
+    buffer.name = relative_path
+    return buffer
+
+
 def as_non_empty_str(value: Any) -> str | None:
     if value is None:
         return None

{euler_loading-2.25.0 → euler_loading-2.28.0}/euler_loading/_resolution.py

@@ -18,6 +18,10 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+#: Built-in loader variants. ``gpu`` returns torch tensors, ``cpu`` NumPy
+#: arrays; automatic resolution from a dataset contract uses ``gpu``.
+LOADER_VARIANTS = ("gpu", "cpu")
+
 _LOADER_MODULES: dict[str, str] = {
     "materialized": "euler_loading.loaders.materialized",
     "vkitti2": "euler_loading.loaders.gpu.vkitti2",
@@ -46,30 +50,45 @@ def _get_euler_loading_meta(index: Mapping[str, Any]) -> Mapping[str, Any] | Non
     return None
 
 
-def resolve_loader_module(name: str) -> ModuleType:
-    """Import and return the GPU loader module for *name*.
+def resolve_loader_module(name: str, *, variant: str = "gpu") -> ModuleType:
+    """Import and return the loader module for *name*.
 
     Example::
 
         module = resolve_loader_module("vkitti2")
         sky_fn = module.sky_mask  # get a specific function
 
+    Args:
+        name: Loader name, as declared by ``addons.euler_loading.loader``.
+        variant: ``"gpu"`` for the torch loaders (the default, and what
+            automatic resolution uses) or ``"cpu"`` for the NumPy ones.
+
     Raises:
-        ValueError: If *name* does not match any known loader.
+        ValueError: If *name* does not match any known loader, or *variant*
+            is neither ``"gpu"`` nor ``"cpu"``.
     """
+    if variant not in LOADER_VARIANTS:
+        available = ", ".join(LOADER_VARIANTS)
+        raise ValueError(
+            f"Unknown loader variant {variant!r}. Available variants: {available}"
+        )
     module_path = _LOADER_MODULES.get(name)
     if module_path is None:
         available = ", ".join(sorted(_LOADER_MODULES))
         raise ValueError(f"Unknown loader {name!r}. Available loaders: {available}")
+    if variant == "cpu":
+        # Loaders that exist in one variant only (``materialized``) are not
+        # registered under ``.gpu.`` and therefore stay as they are.
+        module_path = module_path.replace(".loaders.gpu.", ".loaders.cpu.")
     return importlib.import_module(module_path)
 
 
-def resolve_writer_module(name: str) -> ModuleType:
+def resolve_writer_module(name: str, *, variant: str = "gpu") -> ModuleType:
     """Import and return the writer module for *name*.
 
     Writers live next to loader functions in the same modules.
     """
-    return resolve_loader_module(name)
+    return resolve_loader_module(name, variant=variant)
 
 
 def _builtin_loader_id(loader: Callable[..., Any]) -> str | None:
@@ -119,8 +138,13 @@ def _resolve_loader(
     modality_name: str,
     modality: Modality,
     index: dict[str, Any],
+    variant: str = "gpu",
 ) -> Callable[..., Any]:
-    """Return the effective loader for a modality."""
+    """Return the effective loader for a modality.
+
+    An explicit ``Modality.loader`` always wins; *variant* only selects
+    between the built-in GPU and CPU modules during automatic resolution.
+    """
     if modality.loader is not None:
         return modality.loader
 
@@ -143,7 +167,7 @@ def _resolve_loader(
     module_name: str = euler_loading_meta["loader"]
     func_name: str = euler_loading_meta["function"]
 
-    module = resolve_loader_module(module_name)
+    module = resolve_loader_module(module_name, variant=variant)
 
     func = getattr(module, func_name, None)
     if func is None or not callable(func):
@@ -185,6 +209,7 @@ def _resolve_writer(
     modality_name: str,
     modality: Modality,
     index: dict[str, Any],
+    variant: str = "gpu",
 ) -> Callable[..., Any] | None:
     """Return the effective writer for a modality, if available."""
     if modality.writer is not None:
@@ -200,7 +225,7 @@ def _resolve_writer(
         return None
 
     try:
-        module = resolve_writer_module(module_name)
+        module = resolve_writer_module(module_name, variant=variant)
     except ValueError:
         logger.warning(
             "Modality '%s': cannot resolve writer module %r.",