dclab 0.64.3__tar.gz → 0.66.0__tar.gz

{dclab-0.64.3 → dclab-0.66.0}/CHANGELOG

@@ -1,3 +1,10 @@
+0.66.0
+ - feat: introduce optional identifiers for basins
+ - ref: rename `measurement_identifier` to `referrer_identifier`
+   in the `feat_basin` context to clarify which dataset it belongs to
+0.65.0
+ - scripts: add `vid2dc.py` for converting videos to raw .rtdc files
+ - enh: run identifier splits use "_" upon export and have increased length
 0.64.3
  - ci: use GitHub windows-latest runner for building wheel
 0.64.2

{dclab-0.64.3 → dclab-0.66.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dclab
-Version: 0.64.3
+Version: 0.66.0
 Summary: Library for real-time deformability cytometry (RT-DC)
 Author: Benedikt Hartmann, Eoghan O'Connell, Maik Herbig, Maximilian Schlögel, Nadia Sbaa, Paul Müller, Philipp Rosendahl, Raghava Alajangi
 Maintainer-email: Paul Müller <dev@craban.de>

{dclab-0.64.3 → dclab-0.66.0}/dclab/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.64.3'
-__version_tuple__ = version_tuple = (0, 64, 3)
+__version__ = version = '0.66.0'
+__version_tuple__ = version_tuple = (0, 66, 0)

{dclab-0.64.3 → dclab-0.66.0}/dclab/rtdc_dataset/core.py

@@ -741,7 +741,9 @@ class RTDCBase(abc.ABC):
                 # need the referring dataset.
                 "mapping_referrer": self,
                 # Make sure the measurement identifier is checked.
-                "measurement_identifier": self.get_measurement_identifier(),
+                "referrer_identifier": self.get_measurement_identifier(),
+                # Make sure the basin identifier is checked.
+                "basin_identifier": bdict.get("identifier"),
                 # allow to ignore basins
                 "ignored_basins": bd_keys,
                 # basin key

{dclab-0.64.3 → dclab-0.66.0}/dclab/rtdc_dataset/export.py

@@ -334,8 +334,8 @@ class Export(object):
             # Define a new measurement identifier, so that we are not running
             # into any problems with basins being defined for filtered data.
             ds_run_id = ds.get_measurement_identifier()
-            random_ap = str(uuid.uuid4())[:4]
-            meta["experiment"]["run identifier"] = f"{ds_run_id}-{random_ap}"
+            random_ap = f"dclab-{str(uuid.uuid4())[:7]}"
+            meta["experiment"]["run identifier"] = f"{ds_run_id}_{random_ap}"
 
         if filtered:
             filter_arr = ds.filter.all
@@ -438,7 +438,6 @@ class Export(object):
                 if progress_callback:
                     progress_callback(1 - 1 / (len(features) or 1),
                                       "writing basins")
-
                 # We have to store basins. There are three options:
                 # - filtering disabled: just copy basins
                 # - filtering enabled
@@ -450,6 +449,8 @@ class Export(object):
                 basin_list = [bn.as_dict() for bn in ds.basins]
                 # In addition to the upstream basins, also store a reference
                 # to the original file from which the export was done.
+                # Get the identifier of the current dataset for the new basins.
+                basin_id = ds.get_measurement_identifier()
                 if ds.format in get_basin_classes():
                     # The dataset has a format that matches a basin format
                     # directly.
@@ -464,6 +465,7 @@ class Export(object):
                         "basin_format": ds.format,
                         "basin_locs": basin_locs,
                         "basin_descr": f"Exported with dclab {version}",
+                        "basin_id": basin_id,
                     })
                 elif (ds.format == "hierarchy"
                       and ds.get_root_parent().format in get_basin_classes()):
@@ -497,6 +499,7 @@ class Export(object):
                             child=ds,
                             child_indices=np.arange(len(ds))
                             ),
+                        "basin_id": basin_id,
                     })
 
                 for bn_dict in basin_list:

{dclab-0.64.3 → dclab-0.66.0}/dclab/rtdc_dataset/feat_basin.py

@@ -176,7 +176,8 @@ class Basin(abc.ABC):
                  name: str = None,
                  description: str = None,
                  features: List[str] = None,
-                 measurement_identifier: str = None,
+                 referrer_identifier: str = None,
+                 basin_identifier: str = None,
                  mapping: Literal["same",
                                   "basinmap0",
                                   "basinmap1",
@@ -208,10 +209,18 @@ class Basin(abc.ABC):
         features: list of str
             List of features this basin provides; This list is enforced,
             even if the basin actually contains more features.
-        measurement_identifier: str
+        referrer_identifier: str
             A measurement identifier against which to check the basin.
+            If the basin mapping is "same", then this must match the
+            identifier of the basin exactly, otherwise it must start
+            with the basin identifier (e.g. "basin-id_referrer-sub-id").
             If this is set to None (default), there is no certainty
             that the downstream dataset is from the same measurement.
+        basin_identifier: str
+            A measurement identifier that must match the basin exactly.
+            In contrast to `referrer_identifier`, the basin identifier is
+            the identifier of the basin file. If `basin_identifier` is
+            specified, the identifier of the basin must be identical to it.
         mapping: str
             Which type of mapping to use. This can be either "same"
             when the event list of the basin is identical to that
@@ -261,8 +270,9 @@ class Basin(abc.ABC):
         # features this basin provides
         self._features = features
         #: measurement identifier of the referencing dataset
-        self.measurement_identifier = measurement_identifier
-        self._measurement_identifier_verified = False
+        self.referrer_identifier = referrer_identifier
+        self.basin_identifier = basin_identifier or None
+        self._identifiers_verification = None
         #: ignored basins
         self.ignored_basins = ignored_basins or []
         #: additional keyword arguments passed to the basin
@@ -304,13 +314,13 @@ class Basin(abc.ABC):
 
         return f"<{self.__class__.__name__} ({opt_str}) at {hex(id(self))}>"
 
-    def _assert_measurement_identifier(self):
+    def _assert_referrer_identifier(self):
         """Make sure the basin matches the measurement identifier
         """
         if not self.verify_basin(run_identifier=True):
             raise KeyError(f"Measurement identifier of basin {self.ds} "
                            f"({self.get_measurement_identifier()}) does "
-                           f"not match {self.measurement_identifier}!")
+                           f"not match {self.referrer_identifier}!")
 
     @property
     def basinmap(self):
@@ -410,7 +420,7 @@ class Basin(abc.ABC):
 
     def get_feature_data(self, feat):
         """Return an object representing feature data of the basin"""
-        self._assert_measurement_identifier()
+        self._assert_referrer_identifier()
         return self.ds[feat]
 
     def get_measurement_identifier(self):
@@ -455,20 +465,30 @@ class Basin(abc.ABC):
         # Only check for run identifier if requested and if the availability
         # check did not fail.
         if run_identifier and check_avail:
-            if not self._measurement_identifier_verified:
-                if self.measurement_identifier is None:
+            if self._identifiers_verification is None:
+                # This is the measurement identifier of the basin.
+                basin_identifier = self.get_measurement_identifier()
+
+                # Perform a sanity check for the basin identifier.
+                if (self.basin_identifier
+                        and self.basin_identifier != basin_identifier):
+                    # We should not proceed any further with this basin.
+                    self._identifiers_verification = False
+                    warnings.warn(
+                        f"Basin identifier mismatch for {self}. Expected "
+                        f"'{self.basin_identifier}', got '{basin_identifier}'")
+
+                if self.referrer_identifier is None:
                     # No measurement identifier was presented by the
                     # referencing dataset. We are in the dark.
                     # Don't perform any checks.
-                    self._measurement_identifier_verified = True
+                    self._identifiers_verification = True
                 else:
-                    # This is the measurement identifier of the basin.
-                    basin_identifier = self.get_measurement_identifier()
                     if basin_identifier is None:
                         # Again, we are in the dark, because the basin dataset
                         # does not have an identifier. This is an undesirable
                         # situation, but there is nothing we can do about it.
-                        self._measurement_identifier_verified = True
+                        self._identifiers_verification = True
                     else:
                         if self.mapping == "same":
                             # When we have identical mapping, then the
@@ -479,10 +499,10 @@ class Basin(abc.ABC):
                             # data), then the measurement identifier has to
                             # partially match.
                             verifier = str.startswith
-                        self._measurement_identifier_verified = verifier(
-                            self.measurement_identifier, basin_identifier)
+                        self._identifiers_verification = verifier(
+                            self.referrer_identifier, basin_identifier)
 
-            check_rid = self._measurement_identifier_verified
+            check_rid = self._identifiers_verification
         else:
             check_rid = True
 

{dclab-0.64.3 → dclab-0.66.0}/dclab/rtdc_dataset/writer.py

@@ -207,6 +207,7 @@ class RTDCWriter:
                     basin_descr: str | None = None,
                     basin_feats: List[str] = None,
                     basin_map: np.ndarray | Tuple[str, np.ndarray] = None,
+                    basin_id: str = None,
                     internal_data: Dict | h5py.Group = None,
                     verify: bool = True,
                     perishable: bool = False,
@@ -243,6 +244,12 @@ class RTDCWriter:
             a case, you may specify a tuple `(feature_name, mapping_array)`
             where `feature_name` is the explicit mapping name, e.g.
             `"basinmap3"`.
+        basin_id: str
+            Identifier of the basin. This is the string returned by
+            :meth:`.RTDCBase.get_measurement_identifier`. This is
+            a unique string that identifies the data within a basin.
+            If not specified and `verify=True`, this value is automatically
+            taken from the basin file.
         internal_data: dict or instance of h5py.Group
             A dictionary or an `h5py.Group` containing the basin data.
             The data are copied to the "basin_events" group, if
@@ -310,19 +317,30 @@ class RTDCWriter:
             # We have to import this here to avoid circular imports
             from .load import new_dataset
             # Make sure the basin can be opened by dclab, verify its ID
-            cur_id = self.h5file.attrs.get("experiment:run identifier")
+            ref_id = self.h5file.attrs.get("experiment:run identifier")
             for loc in basin_locs:
                 with new_dataset(loc) as ds:
                     # We can open the file, which is great.
-                    if cur_id:
-                        # Compare the IDs.
-                        ds_id = ds.get_measurement_identifier()
-                        if not (ds_id == cur_id
+                    # Compare the IDs.
+                    bn_id = ds.get_measurement_identifier()
+                    # Check whether `basin_id` matches the actual basin
+                    if basin_id:
+                        if basin_id != bn_id:
+                            raise ValueError(
+                                f"Measurement identifier mismatch for "
+                                f"{loc}: got {bn_id}, expected {basin_id=})!")
+                    else:
+                        # If `basin_id` was not specified, set it here for
+                        # user convenience.
+                        basin_id = bn_id or None
+                    # Check whether the referrer ID matches the basin ID.
+                    if ref_id:
+                        if not (bn_id == ref_id
                                 or (basin_map is not None
-                                    and cur_id.startswith(ds_id))):
+                                    and ref_id.startswith(bn_id))):
                             raise ValueError(
                                 f"Measurement identifier mismatch between "
-                                f"{self.path} ({cur_id}) and {loc} ({ds_id})!")
+                                f"{self.path} ({ref_id}) and {loc} ({bn_id})!")
             if basin_feats:
                 for feat in basin_feats:
                     if not dfn.feature_exists(feat):
@@ -389,6 +407,7 @@ class RTDCWriter:
             "features": None if basin_feats is None else sorted(basin_feats),
             "mapping": basin_map_name,
             "perishable": perishable,
+            "identifier": basin_id,
         }
         if basin_type == "file":
             flocs = []

{dclab-0.64.3 → dclab-0.66.0}/dclab.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dclab
-Version: 0.64.3
+Version: 0.66.0
 Summary: Library for real-time deformability cytometry (RT-DC)
 Author: Benedikt Hartmann, Eoghan O'Connell, Maik Herbig, Maximilian Schlögel, Nadia Sbaa, Paul Müller, Philipp Rosendahl, Raghava Alajangi
 Maintainer-email: Paul Müller <dev@craban.de>

{dclab-0.64.3 → dclab-0.66.0}/dclab.egg-info/SOURCES.txt

@@ -224,6 +224,7 @@ scripts/pixelation_correction.py
 scripts/pixelation_correction_2020.png
 scripts/pixelation_correction_2022.png
 scripts/requirements.txt
+scripts/vid2dc.py
 scripts/lut_recipes/__init__.py
 scripts/lut_recipes/lut_processor.py
 scripts/lut_recipes/hooks/LUT_analytical_linear-elastic_2Daxis.txt

{dclab-0.64.3 → dclab-0.66.0}/docs/sec_av_basins/index.rst

@@ -409,6 +409,7 @@ the json data looks like this:
      "type": "file",
      "features": null,
      "mapping": "basinmap0",
+     "identifier": "1231ae-31f23-342-232-42b1c",
      "paths": [
        "/absolute/path/to/input.rtdc",
        "input.rtdc"
@@ -427,6 +428,11 @@ are a few things to notice:
   ``/events/basinmap0`` in the output file. Note that the fact that this mapping
   information is stored *as a feature* means that it is also properly
   gated when you define basins iteratively.
+- The *identifier* is a string that matches the identifier of the dataset.
+  When creating basins without a "same" mapping (as in this case), then the
+  referrer will obtain an identifier that starts with this identifier, but
+  contains additional text. This means identifiers are effectively cryptic
+  data analysis trackers.
 - There are two *paths* defined, an absolute path (from the root of the file
   system) and a relative path (relative to the directory of the output file).
   This relative path makes it possible to copy-paste these two files *together* to

{dclab-0.64.3 → dclab-0.66.0}/scripts/requirements.txt

@@ -1,5 +1,7 @@
-dclab>=0.23.0
+click
+dclab[tdms]>=0.23.0
 h5py
+imageio[pyav]
 lmfit
 numpy
 matplotlib

dclab-0.66.0/scripts/vid2dc.py

@@ -0,0 +1,240 @@
+"""vid2dc
+
+Convert video files to .rtdc files. This script generates a valid .rtdc
+file from a video file (e.g. an .avi file). This script does not perform
+segmentation and feature extraction, a feature that is available via the
+ChipStream package (https://github.com/DC-analysis/ChipStream).
+
+Prerequisites:
+
+    pip install dclab[tdms] imageio[pyav] click
+
+Author: Paul Müller
+License: GPLv3+
+"""
+import configparser
+import logging
+import pathlib
+import time
+import traceback
+
+import click
+from dclab.rtdc_dataset import fmt_tdms
+from dclab.util import hashfile, hashobj
+from dclab import RTDCWriter
+import h5py
+import imageio.v3 as iio
+import numpy as np
+
+
+logger = logging.getLogger("vid2dc")
+logging.basicConfig(level=logging.INFO)
+
+
+__version__ = "2025.07.07"
+
+
+@click.command()
+@click.argument("path_in",
+                type=click.Path(exists=True,
+                                dir_okay=True,
+                                resolve_path=True,
+                                path_type=pathlib.Path))
+@click.argument("path-out",
+                required=False,
+                type=click.Path(dir_okay=False,
+                                writable=True,
+                                resolve_path=True,
+                                path_type=pathlib.Path),
+                )
+def vid2dc(path_in: pathlib.Path,
+           path_out: pathlib.Path | None = None):
+    """Convert raw video data to raw .rtdc data
+
+    Use this command to convert a video file (e.g. from a legacy
+    .tdms measurement or from a custom setup) to a raw .rtdc file.
+    No segmentation or feature extraction will take place.
+
+    You may also specify an input directory instead of a single file
+    for batch conversion.
+    """
+    if path_in.is_dir():
+        if path_out is not None:
+            raise NotImplementedError("If you pass an input directory, you "
+                                      "must omit the output directory.")
+        for ext in [".avi", ".mp4", ".mpg", ".wmv", ".mkv"]:
+            for pp in path_in.rglob(f"*{ext}"):
+                try:
+                    convert_video_to_dc(video_path=pp)
+                except BaseException:
+                    elog = pp.with_name(pp.stem + "_vid2dc_error.log")
+                    elog.write_text(traceback.format_exc())
+                    click.secho(f"Could not process {pp}, wrote error log "
+                                f"to {elog}.",
+                                bold=True, fg="red")
+    else:
+        convert_video_to_dc(video_path=path_in, dc_path=path_out)
+
+
+def convert_video_to_dc(video_path: str | pathlib.Path,
+                        dc_path: str | pathlib.Path = None,
+                        ):
+    """Convert an .avi file to an .rtdc file
+
+    A valid .rtdc file is produced. Metadata are guessed, but you
+    can put metadata in camera.ini files. This is not fully supported yet.
+    Please check the metadata of the output .rtdc file.
+
+    Parameters
+    ----------
+    video_path:
+        Path to a video file (e.g. an .avi file) to convert to .rtdc.
+    dc_path:
+        Path to an .rtdc file that is created from the video file.
+        If the .rtdc file already exists, it will only be overridden
+        if the input file or metadata changed.
+    """
+    video_path = pathlib.Path(video_path)
+    if dc_path is None:
+        dc_path = video_path.with_name(video_path.stem + "_raw.rtdc")
+    dc_path = pathlib.Path(dc_path)
+
+    # get the dataset configuration
+    config, log_paths = fmt_tdms.RTDC_TDMS.extract_tdms_config(
+        video_path, ret_source_files=True, ignore_missing=True)
+
+    # RecoTeem stores an ini file next to the measurement
+    prt = video_path.with_suffix(".ini")
+    if prt.exists():
+        log_paths.append(prt)
+
+    # read logs
+    logs = {}
+    for ppl in log_paths:
+        logs[ppl.name] = ppl.read_text().split("\n")
+
+    vmeta = iio.improps(video_path)
+    width = vmeta.shape[2]
+    height = vmeta.shape[1]
+
+    config["imaging"].setdefault("frame rate", 2000)
+    config["imaging"].setdefault("pixel size", 0.34)
+    config["imaging"]["roi size x"] = width
+    config["imaging"]["roi size y"] = height
+
+    # extract additional information from an optional ini file (RecoTeem)
+    if prt.exists():
+        # measurement index
+        if prt.name.startswith("M") and prt.name.count("_"):
+            mid = video_path.name.split("_")[0]
+            config["experiment"]["run index"] = int(mid[1:])
+        cp = configparser.RawConfigParser(allow_no_value=True)
+        # Allow upper-case keys (comment for sample name)
+        cp.optionxform = lambda x: x
+        cp.read(prt)
+        rt_fr = cp.getint("set parameter", "frame rate [fps]", fallback=None)
+        # frame rate
+        if rt_fr is not None:
+            config["imaging"]["frame rate"] = rt_fr
+        rt_dur = cp.getfloat("set parameter", "set record time [s]",
+                             fallback=None)
+        # duration
+        if rt_dur is not None:
+            config["online_filter"]["target duration"] = rt_dur / 60
+        # sample name
+        if cp.has_section("Optional Text"):
+            descr = list(cp["Optional Text"].keys())[0]
+            config["experiment"]["sample"] = descr
+
+    # Set the time of the input file
+    tse = video_path.stat().st_mtime
+    loct = time.localtime(tse)
+    # Start time of measurement ('HH:MM:SS')
+    timestr = time.strftime("%H:%M:%S", loct)
+    config["experiment"].setdefault("time", timestr)
+    # Date of measurement ('YYYY-MM-DD')
+    datestr = time.strftime("%Y-%m-%d", loct)
+    config["experiment"].setdefault("date", datestr)
+    config["experiment"].setdefault("sample", video_path.name)
+
+    config["setup"].setdefault("chip region", "channel")
+    config["setup"].setdefault("flow rate", 0)
+    config["setup"].setdefault("software version", f"vid2dc {__version__}")
+
+    config = dict(config)
+    if "filtering" in config:
+        config.pop("filtering")
+
+    # Compute a unique hash of the input files
+    video_hash = hashobj([hashobj(config),
+                          hashfile(video_path),
+                          video_path.stat().st_size,
+                          ])
+
+    # If the output file already exists, check whether the hashes match.
+    log_name = "vid2dc"
+    if dc_path.exists():
+        with h5py.File(dc_path) as h5:
+            if (log_name in h5.get("logs", [])
+                    and h5["logs"][log_name].attrs.get("hash") == video_hash):
+                # We can reuse this file
+                logger.info(f"Reusing existing file {dc_path}")
+                return
+            else:
+                logger.info(f"Rewriting existing {dc_path} (hash mismatch)")
+                dc_path.unlink()
+
+    vid = iio.imiter(video_path)
+
+    # This is the actual workload of this function. Populate the .rtdc
+    # file with the image data.
+    logger.info(f"Writing .rtdc file {dc_path}")
+    with RTDCWriter(dc_path, mode="reset") as hw:
+        # store the image data to the output file in chunks
+        chunk_size = hw.get_best_nd_chunks(item_shape=(height, width),
+                                           item_dtype=np.uint8)[0]
+        image_chunk = np.zeros((chunk_size, height, width), dtype=np.uint8)
+        ii = 0
+        for image in vid:
+            if len(image.shape) == 3:
+                image = image[:, :, 0]
+            image_chunk[ii] = image
+            ii += 1
+            if ii == chunk_size:
+                ii = 0
+                hw.store_feature("image", image_chunk)
+        # store the rest
+        if ii:
+            hw.store_feature("image", image_chunk[:ii])
+
+        event_count = hw.h5file["events/image"].shape[0]
+        config["experiment"]["event count"] = event_count
+        hw.store_metadata(config)
+
+        # store the input file information as a log
+        hw.store_log(
+            name=log_name,
+            lines=[
+                f"Input filename: {video_path.name}",
+                f"Output filename: {dc_path.name}",
+                f"Input file size: {video_path.stat().st_size}",
+                f"Input last edited: {video_path.stat().st_mtime}",
+                f"Unique conversion hash: {video_hash}",
+            ]
+        )
+
+        # store time
+        hw.store_feature(
+            "time",
+            np.arange(event_count) / config["imaging"]["frame rate"])
+        # index starts at 1
+        hw.store_feature("index", np.arange(1, event_count + 1))
+        # frame is an ascending number, just start with 1
+        hw.store_feature("frame", np.arange(1, event_count + 1))
+
+        # only store hash attribute when successful
+        hw.h5file["logs"][log_name].attrs["hash"] = video_hash
+
+
+if __name__ == "__main__":
+    vid2dc()

{dclab-0.64.3 → dclab-0.66.0}/tests/test_rtdc_feat_basin.py

@@ -358,7 +358,10 @@ def test_basin_relative_paths(path_sep):
 @pytest.mark.filterwarnings(
     "ignore::dclab.rtdc_dataset.config.WrongConfigurationTypeWarning")
 def test_basin_key_reproducible():
-    """Since 0.62.9 we sort basin keys"""
+    """
+    Since 0.62.9 we sort basin keys
+    Since 0.66.0 we have identifiers in the basins
+    """
     h5path = retrieve_data("fmt-hdf5_fl_wide-channel_2023.zip")
     h5path_small = h5path.parent / "subdirectory" / "relative.rtdc"
     h5path_small.parent.mkdir()
@@ -409,12 +412,11 @@ def test_basin_key_reproducible():
     # from the input file.
     with dclab.new_dataset(h5path_small_2) as ds:
         assert len(ds.basins) == 1
-        # dclab 0.62.9
         assert ds.basins[0].key in [
             # posix linesep
-            "08dadcb6873a2cf1e5ce781a8887f00f",
+            "b125c0e7d4ab1aff1030f40b87d670c3",
             # win linesep
-            "a1b2aa154724cf46263ad2d41b5b2e1d",
+            "93bc9ab45b50c094c1b585cc8702ca92",
         ]
 
 
@@ -460,6 +462,28 @@ def test_basin_run_identifier_unknown():
         assert ds["image"][0][0, 0] == 126
 
 
+def test_basin_run_identifier_verify():
+    h5path = retrieve_data("fmt-hdf5_fl_wide-channel_2023.zip")
+    export_same = h5path.with_name("same.rtdc")
+
+    # export a subset with basins.
+    with dclab.new_dataset(h5path) as ds:
+        # export without filters
+        ds.export.hdf5(export_same, features=["deform"], basins=True)
+
+    # change the run identifier of the original file
+    with h5py.File(h5path, "a") as h5:
+        h5.attrs["experiment:run identifier"] = "Uiiiid!"
+
+    with dclab.new_dataset(h5path) as ds:
+        assert ds.get_measurement_identifier() == "Uiiiid!"
+
+    with dclab.new_dataset(export_same) as ds2:
+        with pytest.warns(UserWarning, match="identifier mismatch"):
+            with pytest.raises(KeyError, match="does not exist"):
+                ds2["area_um"][0]
+
+
 def test_basin_sorting_basic():
     bnlist = [
         {"type": "remote", "format": "dcor", "ident": 0},