bugfix/convert-dimension-spec-lists-to-slices-when-possible (#429)

* try to convert list to slice when possible

* add some tests

* allow tuples in utility function

* update typing for test function

Author: toloudis

aicsimageio/tests/test_transforms.py

@@ -13,7 +13,12 @@
 from aicsimageio import AICSImage, types
 from aicsimageio.exceptions import ConflictingArgumentsError, UnexpectedShapeError
 from aicsimageio.readers import ArrayLikeReader
-from aicsimageio.transforms import generate_stack, reshape_data, transpose_to_dims
+from aicsimageio.transforms import (
+    generate_stack,
+    reduce_to_slice,
+    reshape_data,
+    transpose_to_dims,
+)
 
 
 @pytest.mark.parametrize("array_maker", [np.zeros, da.zeros])
@@ -523,3 +528,26 @@ def test_generate_stack_mismatch_and_drop(
         xr.testing.assert_allclose(stack, reference)
     else:
         np.testing.assert_allclose(stack, reference)
+
+
+@pytest.mark.parametrize(
+    "list_to_test, expected",
+    [
+        ([0], 0),
+        ([0, 1], slice(0, 2, 1)),
+        ([1, 0], [1, 0]),
+        ([3, 5], slice(3, 6, 2)),
+        ([8, 9, 11], [8, 9, 11]),
+        ([15, 20, 25], slice(15, 26, 5)),
+        ((0,), 0),
+        ((0, 1), slice(0, 2, 1)),
+        ((1, 0), (1, 0)),
+        ((3, 5), slice(3, 6, 2)),
+        ((8, 9, 11), (8, 9, 11)),
+        ((15, 20, 25), slice(15, 26, 5)),
+    ],
+)
+def test_convert_list_to_slice(
+    list_to_test: Union[List, Tuple], expected: Union[int, List, slice, Tuple]
+) -> None:
+    assert reduce_to_slice(list_to_test) == expected

aicsimageio/transforms.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections import Counter
-from typing import Any, Literal, Optional, Union
+from typing import Any, List, Literal, Optional, Tuple, Union
 
 import dask.array as da
 import numpy as np
@@ -16,6 +16,22 @@
 ###############################################################################
 
 
+def reduce_to_slice(L: Union[List, Tuple]) -> Union[int, List, slice, Tuple]:
+    # if the list only has one element, then just use it
+    if len(L) == 1:
+        return L[0]
+    # if the list has at least 2 elements we can check for sliceable
+    # it is convertable to a slice if the step size between each
+    # consecutive pair of elements is equal and positive
+    # 1. get all the deltas in a list:
+    steps = [(L[i + 1] - L[i]) for i in range(len(L) - 1)]
+    # 2. check if all the deltas are equal and positive
+    if steps[0] > 0 and steps.count(steps[0]) == len(steps):
+        return slice(min(L), max(L) + 1, steps[0])
+    # if we can't convert to a slice, then just return the list unmodified
+    return L
+
+
 def transpose_to_dims(
     data: types.ArrayLike,
     given_dims: str,
@@ -208,6 +224,8 @@ def reshape_data(
                 # Get the largest absolute value index in the list using min and max
                 if isinstance(dim_spec, list):
                     check_selection_max = max([abs(min(dim_spec)), max(dim_spec)])
+                    # try to convert to slice if possible
+                    dim_spec = reduce_to_slice(dim_spec)
 
                 # Get the largest absolute value index from start and stop of slice
                 if isinstance(dim_spec, slice):