ngio 0.4.0a4__py3-none-any.whl → 0.4.0b1__py3-none-any.whl

ngio/ome_zarr_meta/ngio_specs/_axes.py

@@ -4,7 +4,6 @@ from collections.abc import Sequence
 from enum import Enum
 from typing import Literal, TypeAlias, TypeVar
 
-import numpy as np
 from pydantic import BaseModel, ConfigDict, Field
 
 from ngio.utils import NgioValidationError, NgioValueError
@@ -263,63 +262,6 @@ def validate_axes(
     )
 
 
-class AxesOps(BaseModel):
-    """Model to represent axes operations.
-
-    This model will be used to transform objects from on disk axes to in memory axes.
-    """
-
-    on_disk_axes: tuple[str, ...]
-    in_memory_axes: tuple[str, ...]
-    transpose_op: tuple[int, ...] | None = None
-    expand_op: tuple[int, ...] | None = None
-    squeeze_op: tuple[int, ...] | None = None
-    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)
-
-    @property
-    def is_no_op(self) -> bool:
-        """Check if all operations are no ops."""
-        if (
-            self.transpose_op is None
-            and self.expand_op is None
-            and self.squeeze_op is None
-        ):
-            return True
-        return False
-
-    @property
-    def get_transpose_op(self) -> tuple[int, ...] | None:
-        """Get the transpose axes."""
-        return self.transpose_op
-
-    @property
-    def get_expand_op(self) -> tuple[int, ...] | None:
-        """Get the expand axes."""
-        return self.expand_op
-
-    @property
-    def get_squeeze_op(self) -> tuple[int, ...] | None:
-        """Get the squeeze axes."""
-        return self.squeeze_op
-
-    @property
-    def set_transpose_op(self) -> tuple[int, ...] | None:
-        """Set the transpose axes."""
-        if self.transpose_op is None:
-            return None
-        return tuple(np.argsort(self.transpose_op))
-
-    @property
-    def set_expand_op(self) -> tuple[int, ...] | None:
-        """Set the expand axes."""
-        return self.squeeze_op
-
-    @property
-    def set_squeeze_op(self) -> tuple[int, ...] | None:
-        """Set the squeeze axes."""
-        return self.expand_op
-
-
 class AxesHandler:
     """This class is used to handle and operate on OME-Zarr axes.
 
@@ -487,6 +429,13 @@ class AxesHandler:
         """Get the index of the axis by name."""
         return self._index_mapping.get(name, None)
 
+    def has_axis(self, axis_name: str) -> bool:
+        """Return whether the axis exists."""
+        index = self.get_index(axis_name)
+        if index is None:
+            return False
+        return True
+
     def get_canonical_name(self, name: str) -> str | None:
         """Get the canonical name of the axis by name."""
         return self._axes_setup.get_canonical_name(name)
@@ -514,79 +463,6 @@ class AxesHandler:
                 new_axes.append(axes)
         self._axes = new_axes
 
-    def _reorder_axes(
-        self, names: Sequence[str]
-    ) -> tuple[tuple[int, ...] | None, tuple[int, ...] | None, tuple[int, ...] | None]:
-        """Change the order of the axes."""
-        # Validate the names
-        unique_names = set(names)
-        if len(unique_names) != len(names):
-            raise NgioValueError(
-                "Duplicate axis names found. Please provide unique names for each axis."
-            )
-        for name in names:
-            if not isinstance(name, str):
-                raise NgioValueError(
-                    f"Invalid axis name '{name}'. Axis names must be strings."
-                )
-        inv_canonical_map = self.axes_setup.inverse_canonical_map()
-
-        # Step 1: Check find squeeze axes
-        _axes_to_squeeze: list[int] = []
-        axes_names_after_squeeze = []
-        for i, ax in enumerate(self.axes_names):
-            # If the axis is not in the names, it means we need to squeeze it
-            ax_canonical = inv_canonical_map.get(ax, None)
-            if ax not in names and ax_canonical not in names:
-                _axes_to_squeeze.append(i)
-            elif ax in names:
-                axes_names_after_squeeze.append(ax)
-            elif ax_canonical in names:
-                # If the axis is in the canonical map, we add it to the names
-                axes_names_after_squeeze.append(ax_canonical)
-
-        axes_to_squeeze = tuple(_axes_to_squeeze) if len(_axes_to_squeeze) > 0 else None
-
-        # Step 2: Find the transposition order
-        _transposition_order: list[int] = []
-        axes_names_after_transpose = []
-        for ax in names:
-            if ax in axes_names_after_squeeze:
-                _transposition_order.append(axes_names_after_squeeze.index(ax))
-                axes_names_after_transpose.append(ax)
-
-        if np.allclose(_transposition_order, range(len(_transposition_order))):
-            # If the transposition order is the identity, we don't need to transpose
-            transposition_order = None
-        else:
-            transposition_order = tuple(_transposition_order)
-
-        # Step 3: Find axes to expand
-        _axes_to_expand: list[int] = []
-        for i, name in enumerate(names):
-            if name not in axes_names_after_transpose:
-                # If the axis is not in the mapping, it means we need to expand it
-                _axes_to_expand.append(i)
-
-        axes_to_expand = tuple(_axes_to_expand) if len(_axes_to_expand) > 0 else None
-        return axes_to_squeeze, transposition_order, axes_to_expand
-
-    def get_axes_ops(self, names: Sequence[str]) -> AxesOps:
-        """Get the axes operations to go from on-disk to in-memory axes."""
-        axes_to_squeeze, transposition_order, axes_to_expand = self._reorder_axes(names)
-        return AxesOps(
-            on_disk_axes=self.axes_names,
-            in_memory_axes=tuple(names),
-            transpose_op=transposition_order,
-            expand_op=axes_to_expand,
-            squeeze_op=axes_to_squeeze,
-        )
-
-    def get_canonical_axes_ops(self) -> AxesOps:
-        """Get the axes operations to go from on-disk to canonical in-memory axes."""
-        other = self._axes_setup.others
-        return self.get_axes_ops(list(self._canonical_order) + other)
-
 
 def build_canonical_axes_handler(
     axes_names: Sequence[str],

ngio/utils/_datasets.py

@@ -38,6 +38,11 @@ class UnzipAndRename(pooch.Unzip):
             return None
 
         tmp_dir = Path(extract_dir) / "tmp"
+        # If tmp_dir exists, remove it
+        if tmp_dir.exists():
+            shutil.rmtree(tmp_dir, ignore_errors=True)
+        tmp_dir.mkdir(parents=True, exist_ok=True)
+
         super()._extract_file(fname, tmp_dir)
 
         list_extracted_dirs = tmp_dir.iterdir()

{ngio-0.4.0a4.dist-info → ngio-0.4.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngio
-Version: 0.4.0a4
+Version: 0.4.0b1
 Summary: Next Generation file format IO
 Project-URL: homepage, https://github.com/BioVisionCenter/ngio
 Project-URL: repository, https://github.com/BioVisionCenter/ngio

{ngio-0.4.0a4.dist-info → ngio-0.4.0b1.dist-info}/RECORD

@@ -1,43 +1,45 @@
 ngio/__init__.py,sha256=rEgnXuU6TCejUUGsxt4eKmjMhxjYh0fYBxWF4o5YjbE,1435
 ngio/common/__init__.py,sha256=aPSuUbdGryrxbnlWrsVNe3LZoBAWC4GijR1BNH1UwuU,612
-ngio/common/_dimensions.py,sha256=zl9mPiYYYxr_s1MT0jQiUhpeG5qAc0l3u-IHgvcJ1XY,10877
+ngio/common/_dimensions.py,sha256=w8PYgyWxA8hgJETjFbw5CXf7WrasCL5FbzgfL1in86M,11361
 ngio/common/_masking_roi.py,sha256=ZZTXordEZoq_ADk0OzADvq-5dPOwUBSuNobzFR8fpTw,5697
 ngio/common/_pyramid.py,sha256=F5OI_mULxzMTpMeihC4Y22cjuB5GKN2jRdpwfMXJHiE,8018
-ngio/common/_roi.py,sha256=gW-_ouxoHrcG5ox6Kl8NOyMhu8XJFKm7xu8w03O6xds,10185
+ngio/common/_roi.py,sha256=DFI2BJdJ-JNC5uZARxlvL25ZYHb9HJhCP-sOID_Db20,10196
 ngio/common/_synt_images_utils.py,sha256=B6uYOW1NyrM06YMR-csca3_YnAAkPRTbvnbLdy9tk9E,3188
 ngio/common/_zoom.py,sha256=U01c-vqXjzZkrpd9Yvs24frVfTls_xPJeeaFCGmUwYI,6727
 ngio/experimental/__init__.py,sha256=3pmBtHi-i8bKjTsvrOJM56ZyRX3Pv_dceCdt88-8COQ,147
-ngio/experimental/iterators/__init__.py,sha256=on_sUvuRhHBb7-r5u3Ojvu6K9FGjUOrWGUkLQ4aRzbs,556
-ngio/experimental/iterators/_abstract_iterator.py,sha256=4YNnL8OZ01KEG0Ga6UuETmXy4TV8oyhYC0ZlB_WLiBA,5537
-ngio/experimental/iterators/_feature.py,sha256=5opX2o9iJazOOro0hEAF0oF7gJtFzmprRd2vusP3lcI,5874
-ngio/experimental/iterators/_image_processing.py,sha256=Dt8mgrlrehwIaHpxNh9e7GSPRme7vWwStdsF9oSwR7E,6082
+ngio/experimental/iterators/__init__.py,sha256=TECOMGb5PEEZ0yXxt8pqIGvLKG41g_L1fTJU-zGPeV8,488
+ngio/experimental/iterators/_abstract_iterator.py,sha256=7aAoMI-6vYGCMKxO3M10WpuBMTdqX4zr0K-TutAOp88,13195
+ngio/experimental/iterators/_feature.py,sha256=g03yHIzYpTVeD3KUq2a4TwX29Dt48XaaGdZNSykYy7M,6749
+ngio/experimental/iterators/_image_processing.py,sha256=cM7sL7xgdcjSOKAu-6367Aov89o6wgiJ_wqCGkU2Bsw,5091
+ngio/experimental/iterators/_mappers.py,sha256=VVVsjems57wJUnWeufUFcgqa23k7VPeFL4Nc04HVw4o,1399
 ngio/experimental/iterators/_rois_utils.py,sha256=Q-8lQ26neYn63h_RvfypYqvrq2UUN2O3xqVe57k_ufU,4363
-ngio/experimental/iterators/_segmentation.py,sha256=M0SVSyBBJDc_pYzMOJJiUmeULk9QXoKe4Lg1EwMz4H8,10276
+ngio/experimental/iterators/_segmentation.py,sha256=xzotGvTn04HPeMeXZ_URnQqWco6d2lH6Ng6vkCUh9NM,9153
 ngio/hcs/__init__.py,sha256=G8j9vD-liLeB_UeGtKYIgshWvJnUA6ks9GwjvWBLdHs,357
 ngio/hcs/_plate.py,sha256=qfRwbCKaoz_AWTi8RDFFwOxy5geSknfJrPcqFVno9zI,44288
 ngio/images/__init__.py,sha256=9Whvt7GTiCgT_vXaEEqGnDaY1-UsRk3dhLTv091F_g4,1211
-ngio/images/_abstract_image.py,sha256=0o1wiNnzHXcSJHAJPd7cMdYatS_B8wT2bcWMzfyFd6A,16841
+ngio/images/_abstract_image.py,sha256=hrB9xn4MFRxnxE1d7HKnM8SXVPUGhMD9u32yBHTsFiU,18517
 ngio/images/_create.py,sha256=61cuco2jUK25WzOY-Sel9s931FtGPL2ut25L9W10bJ4,10171
 ngio/images/_create_synt_container.py,sha256=il_rr5_2KIQ5Xsskj2rb2fEm100ZErZq89aW06kn_7k,5444
-ngio/images/_image.py,sha256=TB-xCGeYRxPj8pzREjj0tkGJz6EqjiUoDLw148ocWi4,32966
-ngio/images/_label.py,sha256=ZQYtsECM04oPrXoiGAWvfIRz7CtsCTPd5ktUMCi-5nA,11712
-ngio/images/_masked_image.py,sha256=0RFW5YudH8cfjLMa263PenBmok2FhYm-eNtgoQkz2Es,18731
+ngio/images/_image.py,sha256=1WQOI26ITn1R2raR9JWVEhp6nKBE3ntXXAQr7EMTOEo,33054
+ngio/images/_label.py,sha256=RIfXrLSKMQ-j8q-aaSiWeIwFEKdxAkQT1HbJNq4PJv0,11800
+ngio/images/_masked_image.py,sha256=YhbBzgPZMav6rX0WYue1BaxAzEIsfaQrxUIOK6ZWZcw,18848
 ngio/images/_ome_zarr_container.py,sha256=UJERXEgBkwclpLaHzWqUIQc6P-TG4zYuKuxPukJGa4Y,38433
 ngio/images/_table_ops.py,sha256=jFv_AMqoB4JBpoWsMtZppZVW7dAOC_u-JpfNm8b33kY,15292
-ngio/io_pipes/__init__.py,sha256=HkqzC1gwGLFzIcHMkgEQ8-rh7w6LDEfvEwkwli-0IHE,1179
-ngio/io_pipes/_io_pipes.py,sha256=loYbsFv0dbpngkd1HYsJ5s9HDcP9lb-QJQBwymSJyg8,8568
-ngio/io_pipes/_io_pipes_masked.py,sha256=jRDS7m4b6Hl7AdxRvg9Dz3nOIl9nypoktj43FHEuBUI,16943
-ngio/io_pipes/_io_pipes_roi.py,sha256=Rgvqy9C-fYEEmg2yoDROE3xiRGhjo5lH5_B8gXvt2dg,4678
-ngio/io_pipes/_io_pipes_utils.py,sha256=r_c1N48L01McTLPRgezW9KGFes3JHQYYkpzOXnQElQ0,10505
+ngio/io_pipes/__init__.py,sha256=arW_7GWzZs82kPNKdm_6B1sIDFV0lWwp-ZaORr9Q1FQ,2412
+ngio/io_pipes/_io_pipes.py,sha256=KuwMYofE11EKx0iplWXBQZ-eE1A9YpGDprWh98cUlAI,10710
+ngio/io_pipes/_io_pipes_masked.py,sha256=077j1XNgyCNOHlOsbjPOWcLtb2ccFvbLp-cPzWL1j3c,16999
+ngio/io_pipes/_io_pipes_roi.py,sha256=E_t3Lb5JD6zgsIok2w98xKks_6vhLIfaKDJIf2J95sA,4809
+ngio/io_pipes/_io_pipes_types.py,sha256=xCeUd9rZe2wsgoZR1pUq6L4LSeawoPsb-9pmz5C6ztA,1393
 ngio/io_pipes/_match_shape.py,sha256=eDy_Eqzld08m9zDuIjAvJnIhWh_HVjQS-5Pw9BMjdbw,13200
-ngio/io_pipes/_ops_axes.py,sha256=BHOSFBGTKF32f4kqj8uu_NpiyLpR0zzBy9HN01OPGSs,4014
-ngio/io_pipes/_ops_slices.py,sha256=9o2HqsiEfeBVcTcTpqmLEKrV-UOkILHdvii-nTXP_0w,7887
-ngio/io_pipes/_ops_transforms.py,sha256=HsxLLGjQ8kx9HpkikYHhXC4s4DD1T56GJ4StjO7FCSk,2946
-ngio/io_pipes/_zoom_transform.py,sha256=Au2nqNfODQWEpvc12OmYVmP-Uso7fEc-14hTK_GsGi4,6723
-ngio/ome_zarr_meta/__init__.py,sha256=A5pyhdyLpwRyXXB81tMHFu36rq9-QzAzG0htRqBMpTo,1293
+ngio/io_pipes/_ops_axes.py,sha256=Geg4ZXxB0njWWopX9YeiwRJJ9Ef2GKfG0NIUafOmi2c,10043
+ngio/io_pipes/_ops_slices.py,sha256=7wBXucmIOW0a1r9MzEVevPOEefyhS27-yhaF8aeyD6Y,15804
+ngio/io_pipes/_ops_slices_utils.py,sha256=mKbAEccwsQjg6XyyJ5Ph5Xr9z6pUUCO3tZ4Yal-wYMs,6590
+ngio/io_pipes/_ops_transforms.py,sha256=uITs6v6sZ7DQ_Hpw3JdX8MuPOzir-bihvGzY84Qn4wY,2934
+ngio/io_pipes/_zoom_transform.py,sha256=bUeFTeGUbz3Io4uArqyHXkvLZmuKsOri1lvMhDXWchA,6716
+ngio/ome_zarr_meta/__init__.py,sha256=tzxW2oVhfeMBVuv3XkcbOLzMnbDvUnie-AVsvSxRkdE,1265
 ngio/ome_zarr_meta/_meta_handlers.py,sha256=ctknNDT8jxwyvxQf9on5gW31H1tRRsnneO38GT2UXoE,25880
-ngio/ome_zarr_meta/ngio_specs/__init__.py,sha256=PXTmXX9aeOlM9FLL-BXzW8v9ByezL_X7EDNx2zoBYm4,1726
-ngio/ome_zarr_meta/ngio_specs/_axes.py,sha256=R2HIL31FreeqawvXQbhRRu3lPxYPviFOSnCOses6Dhw,21134
+ngio/ome_zarr_meta/ngio_specs/__init__.py,sha256=U2FqZR91Ob2N6CqKdyw-_Ll-wMgmGuPZGVRCr6wuRFY,1698
+ngio/ome_zarr_meta/ngio_specs/_axes.py,sha256=gNzxCddn53m9dlNJlV5CL-aQS-nGJrbCDGfAp5L97LY,16412
 ngio/ome_zarr_meta/ngio_specs/_channels.py,sha256=CVsbG52U31TaMdTj8XqvClUdBya2Ar3qBjDo_xhP-NM,16967
 ngio/ome_zarr_meta/ngio_specs/_dataset.py,sha256=CrHnjVWBGYPqErKkHR-E2DKrE3DmGznXMkd3Y9Z4uYo,3434
 ngio/ome_zarr_meta/ngio_specs/_ngio_hcs.py,sha256=N1CGPOubwf0pvm8tiTnh-C1cOu9lToyDe3WagnEnPN4,17207
@@ -72,12 +74,12 @@ ngio/tables/v1/_roi_table.py,sha256=g7UpMmpf3uAfaG59WYRnimUBgiB_T1qUJRwMZpMt9cI,
 ngio/transforms/__init__.py,sha256=JA0-Ui7skbXkm9ofN-AEhU1FTLutkMkwTdVD-310frQ,113
 ngio/transforms/_zoom.py,sha256=otyE-vxFnywUJ8U4mHjat-bNG_7_jv62ckTpqDMxyVQ,550
 ngio/utils/__init__.py,sha256=XPYh8ehC7uXNU2cFFXZAw-S3DpWpX1Yq2xGkffZv5vI,1142
-ngio/utils/_datasets.py,sha256=2g-Neg78dNcqyDz39QQw-Ifp9GITHjVHisdqgvvDNDE,5475
+ngio/utils/_datasets.py,sha256=6GtxfPkjutNaeg5BHuJDBP0GudvQXHLU6mmHp_o0bGA,5650
 ngio/utils/_errors.py,sha256=pKQ12LUjQLYE1nUawemA5h7HsgznjaSvV1n2PQU33N0,759
 ngio/utils/_fractal_fsspec_store.py,sha256=RdcCFOgHexRKX9zZvJV5RI-5OPc7VOPS6q_IeRxm24I,1548
 ngio/utils/_logger.py,sha256=N5W0a_xwze4blS1MolidBkTMbjTbg8GPguJZNun3mAE,1392
 ngio/utils/_zarr_utils.py,sha256=GUOcAx02IcfrJ5tIdKu8ChtRUUaBbkkddW5jaCCYnS8,13797
-ngio-0.4.0a4.dist-info/METADATA,sha256=Xg_Fe1eqlYK8VSvuZO2eRctss4pRDD1hjwgT4v_grHs,5868
-ngio-0.4.0a4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ngio-0.4.0a4.dist-info/licenses/LICENSE,sha256=UgN_a1QCeNh9rZWfz-wORQFxE3elQzLWPQaoK6N6fxQ,1502
-ngio-0.4.0a4.dist-info/RECORD,,
+ngio-0.4.0b1.dist-info/METADATA,sha256=cL8YlW3QecX9Stge_sYlDGi5WAIKIMjoDCvICoqmDFw,5868
+ngio-0.4.0b1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ngio-0.4.0b1.dist-info/licenses/LICENSE,sha256=UgN_a1QCeNh9rZWfz-wORQFxE3elQzLWPQaoK6N6fxQ,1502
+ngio-0.4.0b1.dist-info/RECORD,,

ngio/io_pipes/_io_pipes_utils.py

@@ -1,299 +0,0 @@
-from collections.abc import Mapping, Sequence
-from typing import TypeAlias
-
-from ngio.common._dimensions import Dimensions
-from ngio.io_pipes._ops_slices import SlicingOps, SlicingType
-from ngio.ome_zarr_meta.ngio_specs import Axis
-from ngio.ome_zarr_meta.ngio_specs._axes import AxesOps
-from ngio.utils import NgioValueError
-
-SlicingInputType: TypeAlias = slice | Sequence[int] | int | None
-
-
-def _try_to_slice(value: Sequence[int]) -> slice | tuple[int, ...]:
-    """Try to convert a list of integers into a slice if they are contiguous.
-
-    - If the input is empty, return an empty tuple.
-    - If the input is sorted, and contains contiguous integers,
-      return a slice from the minimum to the maximum integer.
-    - Otherwise, return the input as a tuple.
-
-    This is useful for optimizing array slicing operations
-    by allowing the use of slices when possible, which can be more efficient.
-    """
-    if not value:
-        raise NgioValueError("Ngio does not support empty sequences as slice input.")
-
-    if not all(isinstance(i, int) for i in value):
-        _value = []
-        for i in value:
-            try:
-                _value.append(int(i))
-            except Exception as e:
-                raise NgioValueError(
-                    f"Invalid value {i} of type {type(i)} in sequence {value}"
-                ) from e
-        value = _value
-    # If the input is not sorted, return it as a tuple
-    max_input = max(value)
-    min_input = min(value)
-    assert min_input >= 0, "Input must contain non-negative integers"
-
-    if sorted(value) == list(range(min_input, max_input + 1)):
-        return slice(min_input, max_input + 1)
-
-    return tuple(value)
-
-
-def _remove_channel_slicing(
-    slicing_dict: dict[str, SlicingInputType],
-    dimensions: Dimensions,
-) -> dict[str, SlicingInputType]:
-    """This utility function removes the channel selection from the slice kwargs.
-
-    if ignore_channel_selection is True, it will remove the channel selection
-    regardless of the dimensions. If the ignore_channel_selection is False
-    it will fail.
-    """
-    if dimensions.is_multi_channels:
-        return slicing_dict
-
-    if "c" in slicing_dict:
-        slicing_dict.pop("c", None)
-    return slicing_dict
-
-
-def _check_slicing_virtual_axes(slice_: SlicingInputType) -> bool:
-    """Check if the slice_ is compatible with virtual axes.
-
-    Virtual axes are axes that are not present in the actual data,
-    such as time or channel axes in some datasets.
-    So the only valid slices for virtual axes are:
-    - None: means all data along the axis
-    - 0: means the first element along the axis
-    - slice([0, None], [1, None])
-    """
-    if slice_ is None or slice_ == 0:
-        return True
-    if isinstance(slice_, slice):
-        if slice_.start is None and slice_.stop is None:
-            return True
-        if slice_.start == 0 and slice_.stop is None:
-            return True
-        if slice_.start is None and slice_.stop == 0:
-            return True
-        if slice_.start == 0 and slice_.stop == 1:
-            return True
-    if isinstance(slice_, Sequence):
-        if len(slice_) == 1 and slice_[0] == 0:
-            return True
-    return False
-
-
-def _clean_slicing_dict(
-    dimensions: Dimensions,
-    slicing_dict: Mapping[str, SlicingInputType],
-    remove_channel_selection: bool = False,
-) -> dict[str, SlicingInputType]:
-    """Clean the slicing dict.
-
-    This function will:
-        - Validate that the axes in the slicing_dict are present in the dimensions.
-        - Make sure that the slicing_dict uses the on-disk axis names.
-        - Check for duplicate axis names in the slicing_dict.
-        - Clean up channel selection if the dimensions
-    """
-    clean_slicing_dict: dict[str, SlicingInputType] = {}
-    for axis_name, slice_ in slicing_dict.items():
-        axis = dimensions.axes_handler.get_axis(axis_name)
-        if axis is None:
-            # Virtual axes should be allowed to be selected
-            # Common use case is still allowing channel_selection
-            # When the zarr has not channel axis.
-            if not _check_slicing_virtual_axes(slice_):
-                raise NgioValueError(
-                    f"Invalid axis selection:{axis_name}={slice_}. "
-                    f"Not found on the on-disk axes {dimensions.axes}."
-                )
-            # Virtual axes can be safely ignored
-            continue
-        if axis.name in clean_slicing_dict:
-            raise NgioValueError(
-                f"Duplicate axis {axis.name} in slice kwargs. "
-                "Please provide unique axis names."
-            )
-        clean_slicing_dict[axis.name] = slice_
-
-    if remove_channel_selection:
-        clean_slicing_dict = _remove_channel_slicing(
-            slicing_dict=clean_slicing_dict, dimensions=dimensions
-        )
-    return clean_slicing_dict
-
-
-def _normalize_axes_order(
-    dimensions: Dimensions,
-    axes_order: Sequence[str],
-) -> list[str]:
-    """Convert axes order to the on-disk axes names.
-
-    In this way there is not unambiguity in the axes order.
-    """
-    new_axes_order = []
-    for axis_name in axes_order:
-        axis = dimensions.axes_handler.get_axis(axis_name)
-        if axis is None:
-            new_axes_order.append(axis_name)
-        else:
-            new_axes_order.append(axis.name)
-    return new_axes_order
-
-
-def _normalize_slicing_tuple(
-    axis: Axis,
-    slicing_dict: dict[str, SlicingInputType],
-    no_axes_ops: bool,
-    axes_order: list[str],
-) -> tuple[SlicingType, str | None]:
-    """Normalize the slicing dict to tuple.
-
-    Since the slicing dict can contain different types of values
-    We need to normalize them to more predictable types.
-    The output types are:
-    - slice
-    - int
-    - tuple of int (for non-contiguous selection)
-    """
-    axis_name = axis.name
-    if axis_name not in slicing_dict:
-        # If no slice is provided for the axis, use a full slice
-        return slice(None), None
-
-    value = slicing_dict[axis_name]
-    if value is None:
-        return slice(None), None
-
-    if isinstance(value, slice):
-        return value, None
-    elif isinstance(value, int):
-        # If axes ops are requested, we need to preserve the dimension
-        # When we slice because the axes ops will be applied later
-        # If no axes ops are requested, we can safely keep the integer
-        # which will remove the dimension
-        if (not no_axes_ops) or (axis_name in axes_order):
-            # Axes ops require all dimensions to be preserved
-            value = slice(value, value + 1)
-            return value, None
-        return value, axis_name
-    elif isinstance(value, Sequence):
-        # If a contiguous sequence of integers is provided,
-        # convert it to a slice for efficiency
-        # Alternatively, it will be converted to a tuple of ints
-        return _try_to_slice(value), None
-
-    raise NgioValueError(
-        f"Invalid slice definition {value} of type {type(value)}. "
-        "Allowed types are: int, slice, sequence of int or None."
-    )
-
-
-def _build_slicing_tuple(
-    *,
-    dimensions: Dimensions,
-    slicing_dict: dict[str, SlicingInputType],
-    axes_order: list[str] | None = None,
-    no_axes_ops: bool = False,
-    remove_channel_selection: bool = False,
-) -> tuple[tuple[SlicingType, ...] | None, list[str]]:
-    """Assemble slices to be used to query the array."""
-    if len(slicing_dict) == 0:
-        # Skip unnecessary computation if no slicing is requested
-        return None, []
-    _axes_order = (
-        _normalize_axes_order(dimensions=dimensions, axes_order=axes_order)
-        if axes_order is not None
-        else []
-    )
-    _slicing_dict = _clean_slicing_dict(
-        dimensions=dimensions,
-        slicing_dict=slicing_dict,
-        remove_channel_selection=remove_channel_selection,
-    )
-
-    slicing_tuple = []
-    axes_to_remove = []
-    for axis in dimensions.axes_handler.axes:
-        sl, ax_to_remove = _normalize_slicing_tuple(
-            axis=axis,
-            slicing_dict=_slicing_dict,
-            no_axes_ops=no_axes_ops,
-            axes_order=_axes_order,
-        )
-        slicing_tuple.append(sl)
-        if ax_to_remove is not None:
-            axes_to_remove.append(ax_to_remove)
-    slicing_tuple = tuple(slicing_tuple)
-    # Slicing tuple can have only one element of type tuple
-    # If multiple tuple are present it will lead to errors
-    # when querying the array
-    if sum(isinstance(s, tuple) for s in slicing_tuple) > 1:
-        raise NgioValueError(
-            f"Invalid slicing tuple {slicing_tuple}. Ngio does not support "
-            "multiple non-contiguous selections (tuples) in the slicing tuple. "
-            "Please use slices or single integer selections instead."
-        )
-    return slicing_tuple, axes_to_remove
-
-
-def _build_axes_ops(
-    *,
-    axes_order: Sequence[str] | None,
-    dimensions: Dimensions,
-) -> tuple[list[str] | None, AxesOps]:
-    if axes_order is None:
-        return None, AxesOps(
-            on_disk_axes=dimensions.axes_handler.axes_names,
-            in_memory_axes=dimensions.axes_handler.axes_names,
-        )
-
-    axes_order = _normalize_axes_order(dimensions=dimensions, axes_order=axes_order)
-    axes_ops = dimensions.axes_handler.get_axes_ops(axes_order)
-    return axes_order, axes_ops
-
-
-def setup_io_pipe(
-    *,
-    dimensions: Dimensions,
-    slicing_dict: dict[str, SlicingInputType] | None = None,
-    axes_order: Sequence[str] | None = None,
-    remove_channel_selection: bool = False,
-) -> tuple[SlicingOps, AxesOps]:
-    """Setup the slicing tuple and axes ops for an IO pipe."""
-    slicing_dict = slicing_dict or {}
-    axes_order, axes_ops = _build_axes_ops(
-        axes_order=axes_order,
-        dimensions=dimensions,
-    )
-
-    slicing_tuple, axes_to_remove = _build_slicing_tuple(
-        dimensions=dimensions,
-        slicing_dict=slicing_dict,
-        axes_order=axes_order,
-        no_axes_ops=axes_ops.is_no_op,
-        remove_channel_selection=remove_channel_selection,
-    )
-
-    if axes_to_remove:
-        in_memory_axes = tuple(
-            ax for ax in axes_ops.in_memory_axes if ax not in axes_to_remove
-        )
-        axes_ops = AxesOps(
-            on_disk_axes=axes_ops.on_disk_axes,
-            in_memory_axes=in_memory_axes,
-        )
-    slicing_ops = SlicingOps(
-        on_disk_axes=dimensions.axes_handler.axes_names,
-        slicing_tuple=slicing_tuple,
-        on_disk_shape=dimensions.shape,
-    )
-    return slicing_ops, axes_ops