spatialdata-io 0.7.0__tar.gz → 0.7.1__tar.gz

{spatialdata_io-0.7.0 → spatialdata_io-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spatialdata-io
-Version: 0.7.0
+Version: 0.7.1
 Summary: SpatialData IO for common techs
 Project-URL: Documentation, https://spatialdata-io.readthedocs.io/
 Project-URL: Source, https://github.com/scverse/spatialdata-io

{spatialdata_io-0.7.0 → spatialdata_io-0.7.1}/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.7.0'
-__version_tuple__ = version_tuple = (0, 7, 0)
+__version__ = version = '0.7.1'
+__version_tuple__ = version_tuple = (0, 7, 1)
 
 __commit_id__ = commit_id = None

{spatialdata_io-0.7.0 → spatialdata_io-0.7.1}/src/spatialdata_io/__main__.py

@@ -794,9 +794,9 @@ def xenium_wrapper(
 @_input_output_click_options
 @click.option(
     "--parsing-style",
-    type=click.Choice(["auto", "processed_single_folder", "processed_multiple_folders", "raw"]),
-    default="auto",
-    help="Parsing style for MACSima data. [default: auto]",
+    type=click.Choice(["processed_single_folder", "processed_multiple_folders", "raw"]),
+    default="processed_single_folder",
+    help="Parsing style for MACSima data. [default: processed_single_folder]",
 )
 @click.option(
     "--filter-folder-names",
@@ -870,7 +870,7 @@ def macsima_wrapper(
     input: str,
     output: str,
     *,
-    parsing_style: str = "auto",
+    parsing_style: str = "processed_single_folder",
     filter_folder_names: list[str] | None = None,
     subset: int | None = None,
     c_subset: int | None = None,

{spatialdata_io-0.7.0 → spatialdata_io-0.7.1}/src/spatialdata_io/readers/macsima.py

@@ -48,7 +48,6 @@ class MACSimaParsingStyle(ModeEnum):
     PROCESSED_SINGLE_FOLDER = "processed_single_folder"
     PROCESSED_MULTIPLE_FOLDERS = "processed_multiple_folders"
     RAW = "raw"
-    AUTO = "auto"
 
 
 @dataclass
@@ -62,6 +61,8 @@ class ChannelMetadata:
     roi: int
     fluorophore: str
     exposure: float
+    translation_x: int
+    translation_y: int
     clone: str | None = None  # For example DAPI doesnt have a clone
 
 
@@ -104,6 +105,8 @@ class MultiChannelImage:
                     fluorophore=metadata["fluorophore"],
                     clone=metadata["clone"],
                     exposure=metadata["exposure"],
+                    translation_x=metadata["translation_x"],
+                    translation_y=metadata["translation_y"],
                 )
             )
 
@@ -126,12 +129,11 @@ class MultiChannelImage:
                 ),
             )
         imgs = [imread(img, **imread_kwargs) for img in valid_files]
-        for img, path in zip(imgs, valid_files, strict=True):
-            if img.shape[1:] != imgs[0].shape[1:]:
-                raise ValueError(
-                    f"Images are not all the same size. Image {path} has shape {img.shape[1:]} while the first image "
-                    f"{valid_files[0]} has shape {imgs[0].shape[1:]}"
-                )
+
+        # Pad images to same dimensions if necessary
+        if cls._check_for_differing_xy_dimensions(imgs):
+            imgs = cls._pad_images(imgs, channel_metadata)
+
         # create MultiChannelImage object with imgs and metadata
         output = cls(data=imgs, metadata=channel_metadata)
         return output
@@ -221,10 +223,81 @@ class MultiChannelImage:
     def get_stack(self) -> da.Array:
         return da.stack(self.data, axis=0).squeeze(axis=1)
 
+    @staticmethod
+    def _check_for_differing_xy_dimensions(imgs: list[da.Array]) -> bool:
+        """Checks whether any of the images have differing extent in dimensions X and Y."""
+        # Shape has order CYX
+        dims_x = [x.shape[2] for x in imgs]
+        dims_y = [x.shape[1] for x in imgs]
+
+        dims_x_different = len(set(dims_x)) != 1
+        dims_y_different = len(set(dims_y)) != 1
+
+        different_dimensions = any([dims_x_different, dims_y_different])
+
+        warnings.warn(
+            "Supplied images have different dimensions!",
+            UserWarning,
+            stacklevel=2,
+        )
+
+        return different_dimensions
+
+    @staticmethod
+    def _pad_images(imgs: list[da.Array], channel_metadata: list[ChannelMetadata]) -> list[da.Array]:
+        """Pad all images to the same dimensions in X and Y with 0s.
+
+        Padding obeys translations stored in ome metadata.
+        If no translations are found, padding is added only away from the origin:
+        on the right side for X and at the
+        bottom for Y, so the top-left corner of each image stays aligned.
+        """
+        min_translation_x = min(metadata.translation_x for metadata in channel_metadata)
+        min_translation_y = min(metadata.translation_y for metadata in channel_metadata)
+        normalized_translations_x = [metadata.translation_x - min_translation_x for metadata in channel_metadata]
+        normalized_translations_y = [metadata.translation_y - min_translation_y for metadata in channel_metadata]
+
+        dims_x_max = max(
+            img.shape[2] + translation_x for img, translation_x in zip(imgs, normalized_translations_x, strict=True)
+        )
+        dims_y_max = max(
+            img.shape[1] + translation_y for img, translation_y in zip(imgs, normalized_translations_y, strict=True)
+        )
+
+        warnings.warn(
+            f"Padding images with 0s to same size of ({dims_y_max}, {dims_x_max})",
+            UserWarning,
+            stacklevel=2,
+        )
+
+        padded_imgs = []
+        for img, translation_x, translation_y in zip(
+            imgs, normalized_translations_x, normalized_translations_y, strict=True
+        ):
+            pad_y_prepend = translation_y
+            pad_x_prepend = translation_x
+            # For appending, we check how much space is already covered by the original image, and we take into account how many pixels were prepended
+            # If there still is a difference, we append 0 to get to the same image size
+            pad_y_append = dims_y_max - img.shape[1] - pad_y_prepend
+            pad_x_append = dims_x_max - img.shape[2] - pad_x_prepend
+            # Only pad if necessary
+            if (pad_x_prepend, pad_x_append, pad_y_prepend, pad_y_append) != (0, 0, 0, 0):
+                pad_width = (
+                    # c axis: no pad
+                    (0, 0),
+                    (pad_y_prepend, pad_y_append),
+                    (pad_x_prepend, pad_x_append),
+                )
+
+                img = da.pad(img, pad_width, mode="constant", constant_values=0)
+            padded_imgs.append(img)
+
+        return padded_imgs
+
 
 def macsima(
     path: str | Path,
-    parsing_style: MACSimaParsingStyle | str = MACSimaParsingStyle.AUTO,
+    parsing_style: MACSimaParsingStyle | str = MACSimaParsingStyle.PROCESSED_SINGLE_FOLDER,
     filter_folder_names: list[str] | None = None,
     imread_kwargs: Mapping[str, Any] = MappingProxyType({}),
     subset: int | None = None,
@@ -245,6 +318,8 @@ def macsima(
     This function reads images from a MACSima cyclic imaging experiment. MACSima data follows the OME-TIFF specificiation.
     All metadata is parsed from the OME metadata. The exact metadata schema can change between software versions of MACSiQView.
     As there is no public specification of the metadata fields used, please consider the provided test data sets as ground truth to guide development.
+    If images from different cycles differ in spatial dimensions, they are zero-padded on the right (X) and bottom (Y) to match
+    the largest dimensions, keeping the top-left origin aligned; a warning is emitted in that case.
 
     .. seealso::
 
@@ -255,7 +330,8 @@ def macsima(
     path
         Path to the directory containing the data.
     parsing_style
-        Parsing style to use. If ``auto``, the parsing style is determined based on the contents of the path.
+        Parsing style to use. If ``processed_single_folder``, all subfolders of ``path`` are combined into a stack.
+        If ``processed_multiple_folders``, a stack is created for each folder directly beneath ``path``.
     filter_folder_names
         List of folder names to filter out when parsing multiple folders.
     imread_kwargs
@@ -295,19 +371,13 @@ def macsima(
     if not isinstance(parsing_style, MACSimaParsingStyle):
         parsing_style = MACSimaParsingStyle(parsing_style)
 
-    if parsing_style == MACSimaParsingStyle.AUTO:
-        assert path.is_dir(), f"Path {path} is not a directory."
-
-        if any(p.suffix in [".tif", ".tiff"] for p in path.iterdir()):
-            # if path contains tifs, do parse_processed_folder on path
-            parsing_style = MACSimaParsingStyle.PROCESSED_SINGLE_FOLDER
-        elif all(p.is_dir() for p in path.iterdir() if not p.name.startswith(".")):
-            # if path contains only folders or hidden files, do parse_processed_folder on each folder
-            parsing_style = MACSimaParsingStyle.PROCESSED_MULTIPLE_FOLDERS
-        else:
-            raise ValueError(f"Cannot determine parsing style for path {path}. Please specify the parsing style.")
-
     if parsing_style == MACSimaParsingStyle.PROCESSED_SINGLE_FOLDER:
+        if filter_folder_names:
+            warnings.warn(
+                "single_processed_folder was requested but filter_folder_names was specified. Note that it is ignored here, filtering only happens for processed_multi_folders!",
+                UserWarning,
+                stacklevel=2,
+            )
         return parse_processed_folder(
             path=path,
             imread_kwargs=imread_kwargs,
@@ -332,6 +402,9 @@ def macsima(
             for p in path.iterdir()
             if p.is_dir() and (not filter_folder_names or not any(f in p.name for f in filter_folder_names))
         ]:
+            if not len(list(p.glob("*.tif*"))):
+                warnings.warn(f"No tif files found in {p}, skipping it!", UserWarning, stacklevel=2)
+                continue
             sdatas[p.stem] = parse_processed_folder(
                 path=p,
                 imread_kwargs=imread_kwargs,
@@ -415,6 +488,25 @@ def _get_software_major_version(version: str) -> int:
     return major
 
 
+def _get_translations(ome: OME) -> dict[str, int]:
+    try:
+        translations = {
+            "translation_x": ome.images[0].pixels.planes[0].position_x,
+            "translation_y": ome.images[0].pixels.planes[0].position_y,
+        }
+        # If the position attributes are not present the values will be None and we default to (0,0)
+        if any(v is None for v in translations.values()):
+            logger.debug(f"No translation found for {ome.images[0].name}, defaulting to (0, 0)")
+            translations = {"translation_x": 0, "translation_y": 0}
+
+    # In case the ome is faulty, also default to (0,0)
+    except AttributeError:
+        logger.debug(f"No translation found for {ome.images[0].name}, defaulting to (0, 0)")
+        translations = {"translation_x": 0, "translation_y": 0}
+
+    return translations
+
+
 def _parse_v0_ome_metadata(ome: OME) -> dict[str, Any]:
     """Parse Legacy Format of OME Metadata (software version 0.x.x)."""
     logger.debug("Parsing OME metadata expecting version 0 format")
@@ -592,12 +684,16 @@ def _parse_ome_metadata(ome: OME) -> dict[str, Any]:
     major = _get_software_major_version(version_str)
 
     if major == 0:
-        return _parse_v0_ome_metadata(ome)
+        metadata = _parse_v0_ome_metadata(ome)
     elif major == 1:
-        return _parse_v1_ome_metadata(ome)
+        metadata = _parse_v1_ome_metadata(ome)
     else:
         raise ValueError("Unknown software version, cannot determine parser")
 
+    translations = _get_translations(ome)
+    metadata.update(translations)
+    return metadata
+
 
 def parse_metadata(path: Path) -> dict[str, Any]:
     """Parse metadata for a file.
@@ -625,7 +721,7 @@ def parse_processed_folder(
     nuclei_channel_name: str = "DAPI",
     split_threshold_nuclei_channel: int | None = 2,
     skip_rounds: list[int] | None = None,
-    file_pattern: str = "*.tif*",
+    file_pattern: str = "**/*.tif*",
     include_cycle_in_channel_name: bool = False,
 ) -> SpatialData:
     """Parse a single folder containing images from a cyclical imaging platform."""
@@ -760,6 +856,7 @@ def create_table(mci: MultiChannelImage) -> ad.AnnData:
     clones = mci.get_clones()
     exposures = mci.get_exposures()
 
+    # We dont add the translations, because they are usually not interesting for the user
     df = pd.DataFrame(
         {
             "name": names,

{spatialdata_io-0.7.0 → spatialdata_io-0.7.1}/src/spatialdata_io/readers/xenium.py

@@ -605,6 +605,7 @@ def _get_polygons(
         else:
             # Use cell_id (str) as GeoDataFrame index.
             geo_df = GeoDataFrame({"geometry": geoms}, index=indices_mapping["cell_id"].values)
+            geo_df.index.name = "cell_id"
     else:
         # Fall back to extracting unique cell IDs from parquet (slow for large_string columns).
         # Triggered when indices_mapping is None: v < 1.3.0 (both nuclei and cells, because
@@ -617,6 +618,7 @@ def _get_polygons(
         unique_ids = id_col.filter(np.concatenate([[True], change_mask])).to_pylist()
         index = _decode_cell_id_column(pd.Series(unique_ids))
         geo_df = GeoDataFrame({"geometry": geoms}, index=index.values)
+        geo_df.index.name = "cell_id"
 
     scale = Scale([1.0 / specs["pixel_size"], 1.0 / specs["pixel_size"]], axes=("x", "y"))
     return ShapesModel.parse(geo_df, transformations={"global": scale})

{spatialdata_io-0.7.0 → spatialdata_io-0.7.1}/tests/test_macsima.py

@@ -1,4 +1,6 @@
+import contextlib
 import math
+import os
 import shutil
 from copy import deepcopy
 from pathlib import Path
@@ -12,7 +14,12 @@ import pytest
 from click.testing import CliRunner
 from ome_types import OME
 from ome_types.model import (
+    Image,
     MapAnnotation,
+    Pixels,
+    Pixels_DimensionOrder,
+    PixelType,
+    Plane,
     Plate,
     Reagent,
     Screen,
@@ -30,12 +37,12 @@ from spatialdata_io.readers.macsima import (
     _collect_map_annotation_values,
     _get_software_major_version,
     _get_software_version,
+    _get_translations,
     _parse_ome_metadata,
     _parse_v0_ome_metadata,
     _parse_v1_ome_metadata,
     macsima,
 )
-from tests._utils import skip_if_below_python_version
 
 RNG = da.random.default_rng(seed=0)
 
@@ -52,21 +59,25 @@ if not (Path("./data/OMAP10_small").exists() or Path("./data/OMAP23_small").exis
 def make_ChannelMetadata(
     name: str,
     cycle: int,
-    fluorophore: str | None = None,
-    exposure: float | None = None,
-    imagetype: str | None = None,
-    well: str | None = None,
-    roi: int | None = None,
+    fluorophore: str = "",
+    exposure: float = 0.0,
+    imagetype: str = "StainCycle",
+    well: str = "A01",
+    roi: int = 0,
+    translation_x: int = 0,
+    translation_y: int = 0,
 ) -> ChannelMetadata:
     """Helper to construct ChannelMetadata with required defaults."""
     return ChannelMetadata(
         name=name,
         cycle=cycle,
-        fluorophore=fluorophore or "",
-        exposure=exposure if exposure is not None else 0.0,
-        imagetype=imagetype or "StainCycle",
-        well=well or "A01",
-        roi=roi if roi is not None else 0,
+        fluorophore=fluorophore,
+        exposure=exposure,
+        imagetype=imagetype,
+        well=well,
+        translation_x=translation_x,
+        translation_y=translation_y,
+        roi=roi,
     )
 
 
@@ -93,7 +104,7 @@ def test_exception_on_no_valid_files(tmp_path: Path) -> None:
     # Write a tiff file without metadata
     height = 10
     width = 10
-    arr = np.zeros((height, width, 1), dtype=np.uint16)
+    arr = np.zeros((1, height, width), dtype=np.uint16)
     path_no_metadata = Path(tmp_path) / "tiff_no_metadata.tiff"
     imwrite(path_no_metadata, arr, metadata=None, description=None, software=None, datetime=None)
 
@@ -101,7 +112,114 @@ def test_exception_on_no_valid_files(tmp_path: Path) -> None:
         macsima(tmp_path)
 
 
-@skip_if_below_python_version()
+def test_multiple_subfolder_parsing_skips_emtpy_folders(tmp_path: Path) -> None:
+    parent_folder = tmp_path / "test_folder"
+    shutil.copytree("./data/OMAP23_small", parent_folder / "OMAP23_small")
+    os.makedirs(parent_folder / "empty_folder")
+
+    with pytest.warns(UserWarning, match="No tif files found in .* skipping it"):
+        sdata = macsima(parent_folder, parsing_style="processed_multiple_folders")
+    assert len(sdata.images.keys()) == 1
+
+
+@pytest.mark.parametrize(
+    "dimensions,expected",
+    [
+        (((10, 10), (10, 10)), False),
+        (((10, 10), (15, 10)), True),
+        (((10, 10), (10, 15)), True),
+        (((15, 10), (10, 15)), True),
+    ],
+)
+def test_check_differing_dimensions_works(dimensions: tuple[tuple[int, int], tuple[int, int]], expected: bool) -> None:
+    imgs = []
+    for img_dim in dimensions:
+        arr = da.from_array(np.ones((1, img_dim[0], img_dim[1]), dtype=np.uint16))
+        imgs.append(arr)
+
+    ctx = (
+        pytest.warns(UserWarning, match="Supplied images have different dimensions!")
+        if expected
+        else contextlib.nullcontext()
+    )
+    with ctx:
+        assert MultiChannelImage._check_for_differing_xy_dimensions(imgs) == expected
+
+
+def test_padding_on_differing_dimensions() -> None:
+    # Simple test where all translations are 0
+    # Here we expect to pad to the largest element.
+    heights = [10, 10, 15, 20]
+    widths = [10, 15, 10, 20]
+
+    imgs = []
+    for height, width in zip(heights, widths, strict=True):
+        arr = da.from_array(np.ones((1, height, width), dtype=np.uint16))
+        imgs.append(arr)
+
+    channel_metadata = [make_ChannelMetadata(name="test", cycle=1)] * 4
+    with pytest.warns(UserWarning, match="Padding images with 0s to same size of \\(20, 20\\)"):
+        imgs_padded = MultiChannelImage._pad_images(imgs, channel_metadata)
+    for img in imgs_padded:
+        assert img.shape == (1, 20, 20)
+
+    # More complex with non-zero translations
+    # First test that padding does the minimal padding necessary.
+    # To do this create images with very large, but identical translations. Since all of these should be normalized out we expect size 20x20 again.
+    heights = [10, 10, 15, 20]
+    widths = [10, 15, 10, 20]
+
+    imgs = []
+    for height, width in zip(heights, widths, strict=True):
+        arr = da.from_array(np.ones((1, height, width), dtype=np.uint16))
+        imgs.append(arr)
+    channel_metadata = channel_metadata = [
+        make_ChannelMetadata(name="test", cycle=1, translation_x=100, translation_y=100)
+    ] * 4
+    with pytest.warns(UserWarning, match="Padding images with 0s to same size of \\(20, 20\\)"):
+        imgs_padded = MultiChannelImage._pad_images(imgs, channel_metadata)
+    for img in imgs_padded:
+        assert img.shape == (1, 20, 20)
+
+    # Test with differing translations but same size.
+    # As we translate the first image by 2 in x and 3 in y, we expect a 13x12 image
+    heights = [10, 10]
+    widths = [10, 10]
+
+    imgs = []
+    for height, width in zip(heights, widths, strict=True):
+        arr = da.from_array(np.ones((1, height, width), dtype=np.uint16))
+        imgs.append(arr)
+    channel_metadata = channel_metadata = [
+        make_ChannelMetadata(name="test", cycle=1, translation_x=2, translation_y=3),
+        make_ChannelMetadata(name="test", cycle=1, translation_x=0, translation_y=0),
+    ]
+    with pytest.warns(UserWarning, match="Padding images with 0s to same size of \\(13, 12\\)"):
+        imgs_padded = MultiChannelImage._pad_images(imgs, channel_metadata)
+    for img in imgs_padded:
+        assert img.shape == (1, 13, 12)
+
+    # Final test with differing image sizes, and translations that need to be normalized
+    # For the total size, we need to check the sum of each image dimension + normalized translation
+    # Here that would be image 2, with y = 15 + 5 - 3 = 17 (normalized to other image!) and x = 15 + 5 - 2 = 18
+
+    heights = [10, 15]
+    widths = [10, 15]
+
+    imgs = []
+    for height, width in zip(heights, widths, strict=True):
+        arr = da.from_array(np.ones((1, height, width), dtype=np.uint16))
+        imgs.append(arr)
+    channel_metadata = channel_metadata = [
+        make_ChannelMetadata(name="test", cycle=1, translation_x=2, translation_y=3),
+        make_ChannelMetadata(name="test", cycle=1, translation_x=5, translation_y=5),
+    ]
+    with pytest.warns(UserWarning, match="Padding images with 0s to same size of \\(17, 18\\)"):
+        imgs_padded = MultiChannelImage._pad_images(imgs, channel_metadata)
+    for img in imgs_padded:
+        assert img.shape == (1, 17, 18)
+
+
 @pytest.mark.parametrize(
     "dataset,expected",
     [
@@ -123,7 +241,6 @@ def test_image_size(dataset: str, expected: dict[str, Any]) -> None:
     assert extent == expected
 
 
-@skip_if_below_python_version()
 @pytest.mark.parametrize(
     "dataset,expected",
     [("OMAP10_small", 4), ("OMAP23_small", 5)],
@@ -139,7 +256,6 @@ def test_total_channels(dataset: str, expected: int) -> None:
     assert channels == expected
 
 
-@skip_if_below_python_version()
 @pytest.mark.parametrize(
     "dataset,expected",
     [
@@ -161,7 +277,6 @@ def test_channel_names_with_cycle_in_name(dataset: str, expected: list[str]) ->
     assert list(channels) == expected
 
 
-@skip_if_below_python_version()
 @pytest.mark.parametrize(
     "dataset,expected",
     [
@@ -178,7 +293,6 @@ def test_total_rounds(dataset: str, expected: list[int]) -> None:
     assert max_cycle == expected
 
 
-@skip_if_below_python_version()
 @pytest.mark.parametrize(
     "dataset,skip_rounds,expected",
     [
@@ -201,6 +315,57 @@ def test_skip_rounds(dataset: str, skip_rounds: list[int], expected: list[str])
     assert list(channels) == expected, f"Expected {expected}, got {list(channels)}"
 
 
+def test_unsupported_parsing_styles() -> None:
+    with pytest.raises(ValueError, match="Invalid option `not_a_parsing_style` for `MACSimaParsingStyle`."):
+        macsima(Path(), parsing_style="not_a_parsing_style")
+
+
+def test_processed_single_folder_parsing_returns_a_single_image_stack(tmp_path: Path) -> None:
+    omap10_path = Path("./data/OMAP10_small")
+    shutil.copytree(omap10_path, tmp_path / "OMAP10_small_1")
+    shutil.copytree(omap10_path, tmp_path / "OMAP10_small_2")
+
+    sdata = macsima(tmp_path, parsing_style="processed_single_folder")
+
+    assert len(sdata.images) == 1
+    # omap10_small has 4 channels, so we expect 8 here
+    el = sdata[list(sdata.images.keys())[0]]
+    assert len(get_channel_names(el)) == 8
+    assert len(sdata.tables) == 1
+
+
+def test_processed_single_folder_parsing_warns_when_specifying_filtered_folders(tmp_path: Path) -> None:
+    omap10_path = Path("./data/OMAP10_small")
+    shutil.copytree(omap10_path, tmp_path / "OMAP10_small_1")
+    shutil.copytree(omap10_path, tmp_path / "OMAP10_small_2")
+    with pytest.warns(UserWarning, match="filtering only happens for processed_multi_folders"):
+        macsima(tmp_path, parsing_style="processed_single_folder", filter_folder_names=["OMAP10_small_2"])
+
+
+def test_processed_multiple_folders_returns_an_image_stack_per_subfolder(tmp_path: Path) -> None:
+    omap10_path = Path("./data/OMAP10_small")
+    shutil.copytree(omap10_path, tmp_path / "OMAP10_small_1")
+    shutil.copytree(omap10_path, tmp_path / "OMAP10_small_2")
+
+    sdata = macsima(tmp_path, parsing_style="processed_multiple_folders")
+
+    assert len(sdata.images) == 2
+    for el in sdata.images.keys():
+        assert len(get_channel_names(sdata[el])) == 4
+    assert len(sdata.tables) == 2
+
+
+def test_processed_multiple_folders_skips_filtered_folder_names(tmp_path: Path) -> None:
+    shutil.copytree(Path("./data/OMAP10_small"), tmp_path / "OMAP10_small")
+    shutil.copytree(Path("./data/OMAP23_small"), tmp_path / "OMAP23_small")
+
+    sdata = macsima(tmp_path, parsing_style="processed_multiple_folders", filter_folder_names=["OMAP10_small"])
+    assert len(sdata.images) == 1
+    assert list(sdata.images.keys()) == ["OMAP23_small_image"]
+    assert len(sdata.tables) == 1
+    assert list(sdata.tables.keys()) == ["OMAP23_small_table"]
+
+
 METADATA_COLUMN_ORDER = [
     "cycle",
     "imagetype",
@@ -242,7 +407,6 @@ EXPECTED_METADATA_OMAP23 = pd.DataFrame(
 )
 
 
-@skip_if_below_python_version()
 @pytest.mark.parametrize(
     "dataset,expected_df",
     [
@@ -262,11 +426,6 @@ def test_metadata_table(dataset: str, expected_df: pd.DataFrame) -> None:
     pd.testing.assert_frame_equal(actual, expected_df)
 
 
-def test_parsing_style() -> None:
-    with pytest.raises(ValueError):
-        macsima(Path(), parsing_style="not_a_parsing_style")
-
-
 def test_mci_sort_by_channel() -> None:
     sizes = [100, 200, 300]
     c_names = ["test11", "test3", "test2"]
@@ -315,7 +474,6 @@ def test_mci_array_reference() -> None:
     assert da.all(mci.data[0] == orig_arr1)
 
 
-@skip_if_below_python_version()
 @pytest.mark.parametrize("dataset", ["OMAP10_small", "OMAP23_small"])
 def test_cli_macsima(runner: CliRunner, dataset: str) -> None:
     f = Path("./data") / dataset
@@ -645,15 +803,77 @@ def test_parse_v1_ome_metadata_handles_unknown_imagetypes() -> None:
     assert md["imagetype"] == "NOT A VALID TYPE"
 
 
-def make_ome_with_version(version_value: str, extra_ma: dict[str, Any] | None = None) -> OME:
-    base = {"SoftwareVersion": version_value}
+def test_get_translations_returns_correct_values() -> None:
+    ome = OME(
+        images=[
+            Image(
+                pixels=Pixels(
+                    dimension_order=Pixels_DimensionOrder("XYZCT"),
+                    type=PixelType.UINT16,
+                    size_x=1,
+                    size_y=1,
+                    size_z=1,
+                    size_c=1,
+                    size_t=1,
+                    planes=[Plane(position_x=1, position_y=2, the_z=0, the_t=0, the_c=0)],
+                )
+            )
+        ]
+    )
+    expected = {"translation_x": 1, "translation_y": 2}
+
+    translations = _get_translations(ome)
+    assert translations == expected
+
+
+def test_get_translations_defaults_to_0_on_missing_data() -> None:
+    ome = OME(
+        images=[
+            Image(
+                pixels=Pixels(
+                    dimension_order=Pixels_DimensionOrder("XYZCT"),
+                    type=PixelType.UINT16,
+                    size_x=1,
+                    size_y=1,
+                    size_z=1,
+                    size_c=1,
+                    size_t=1,
+                    planes=[Plane(the_z=0, the_t=0, the_c=0)],
+                )
+            )
+        ],
+    )
+    expected = {"translation_x": 0, "translation_y": 0}
+
+    translations = _get_translations(ome)
+    assert translations == expected
+
+
+def make_ome(extra_ma: dict[str, Any] | None = None) -> OME:
+    base = {}
     if extra_ma:
         base.update(extra_ma)
-    return OME(structured_annotations=StructuredAnnotations(map_annotations=[MapAnnotation(value=base)]))
+    return OME(
+        images=[
+            Image(
+                pixels=Pixels(
+                    dimension_order=Pixels_DimensionOrder("XYZCT"),
+                    type=PixelType.UINT16,
+                    size_x=1,
+                    size_y=1,
+                    size_z=1,
+                    size_c=1,
+                    size_t=1,
+                    planes=[Plane(the_z=0, the_t=0, the_c=0)],
+                )
+            )
+        ],
+        structured_annotations=StructuredAnnotations(map_annotations=[MapAnnotation(value=base)]),
+    )
 
 
 def test_parse_ome_metadata_dispatches_to_v0() -> None:
-    ome = make_ome_with_version("0.9.0")
+    ome = make_ome(extra_ma={"SoftwareVersion": "0.9.0"})
     # enrich some so v0 parser has something to see
     ome.screens = [Screen(reagents=[Reagent(name="Marker0")])]
 
@@ -666,15 +886,14 @@ def test_parse_ome_metadata_dispatches_to_v0() -> None:
 
 
 def test_parse_ome_metadata_dispatches_to_v1() -> None:
-    ome = make_ome_with_version("1.0.0", extra_ma={"Biomarker": "CD3"})
-
+    ome = make_ome(extra_ma={"SoftwareVersion": "1.0.0", "Biomarker": "CD3"})
     md = _parse_ome_metadata(ome)
 
     assert md["name"] == "CD3"
 
 
 def test_parse_ome_metadata_unknown_major_raises() -> None:
-    ome = make_ome_with_version("2.0.0")
+    ome = make_ome(extra_ma={"SoftwareVersion": "2.0.0"})
 
     with pytest.raises(ValueError, match="Unknown software version"):
         _parse_ome_metadata(ome)

{spatialdata_io-0.7.0 → spatialdata_io-0.7.1}/tests/test_xenium.py

@@ -114,6 +114,7 @@ def test_example_data_index_integrity(dataset: str) -> None:
         assert sdata["nucleus_labels"]["scale0"]["image"].sel(y=3515.5, x=4618.5).data.compute() == 6392
         assert np.allclose(sdata['transcripts'].compute().loc[[0, 10000, 1113949]]['x'], [2.608911, 194.917831, 1227.499268])
         assert np.isclose(sdata['cell_boundaries'].loc['oipggjko-1'].geometry.centroid.x,736.4864931162789)
+        assert sdata['cell_boundaries'].index.name == 'cell_id'
         index = sdata['nucleus_boundaries']['cell_id'].index[sdata['nucleus_boundaries']['cell_id'].eq('oipggjko-1')][0]
         assert np.isclose(sdata['nucleus_boundaries'].loc[index].geometry.centroid.x,736.4931256878282)
         assert np.array_equal(sdata['table'].X.indices[:3], [1, 3, 34])
@@ -140,6 +141,7 @@ def test_example_data_index_integrity(dataset: str) -> None:
         assert sdata["nucleus_labels"]["scale0"]["image"].sel(y=18.5, x=3015.5).data.compute() == 2764
         assert np.allclose(sdata['transcripts'].compute().loc[[0, 10000, 20000]]['x'], [174.258392, 12.210024, 214.759186])
         assert np.isclose(sdata['cell_boundaries'].loc['aaanbaof-1'].geometry.centroid.x, 43.96894317275074)
+        assert sdata['cell_boundaries'].index.name == 'cell_id'
         index = sdata['nucleus_boundaries']['cell_id'].index[sdata['nucleus_boundaries']['cell_id'].eq('aaanbaof-1')][0]
         assert np.isclose(sdata['nucleus_boundaries'].loc[index].geometry.centroid.x,43.31874577809517)
         assert np.array_equal(sdata['table'].X.indices[:3], [1, 8, 19])
@@ -167,6 +169,7 @@ def test_example_data_index_integrity(dataset: str) -> None:
         assert sdata["nucleus_labels"]["scale0"]["image"].sel(y=4039.5, x=93.5).data.compute() == 274
         assert np.allclose(sdata['transcripts'].compute().loc[[0, 10000, 20000]]['x'], [43.296875, 62.484375, 93.125])
         assert np.isclose(sdata['cell_boundaries'].loc['aadmbfof-1'].geometry.centroid.x, 64.54541104696033)
+        assert sdata['cell_boundaries'].index.name == 'cell_id'
         index = sdata['nucleus_boundaries']['cell_id'].index[sdata['nucleus_boundaries']['cell_id'].eq('aadmbfof-1')][0]
         assert np.isclose(sdata['nucleus_boundaries'].loc[index].geometry.centroid.x, 65.43305896114295)
         assert np.array_equal(sdata['table'].X.indices[:3], [3, 49, 53])