impy-array 2.4.1__tar.gz → 2.4.3__tar.gz

{impy_array-2.4.1 → impy_array-2.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: impy-array
-Version: 2.4.1
+Version: 2.4.3
 Summary: Speed up coding/extending image analysis in Python.
 Project-URL: Download, https://github.com/hanjinliu/impy
 Author-email: Hanjin Liu <liuhanjin-sc@g.ecc.u-tokyo.ac.jp>
@@ -120,8 +120,9 @@ or where to save the image. As a result, **your code will be very concise**:
 import impy as ip
 import numpy as np
 
-img = ip.imread("path/to/image")       # Read images with metadata.
+img = ip.imread("path/to/image.tif")   # Read images with metadata.
 img["z=3;t=0"].imshow()                # Plot image slice at z=3 and t=0.
+img["y=N//4:N//4*3"].imshow()          # `N` for the size of the axis.
 img_fil = img.gaussian_filter(sigma=2) # Paralell batch denoising. No more for loop!
 img_prj = np.max(img_fil, axis="z")    # Z-projection (numpy is aware of image axes!).
 img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend time on searching for the directory!
@@ -134,6 +135,7 @@ img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend tim
 - Tiff file (".tif", ".tiff")
 - MRC file (".mrc", ".rec", ".st", ".map", ".map.gz")
 - Zarr file (".zarr")
+- ND2 file (".nd2")
 - Other image file (".png", ".jpg")
 
 ### Lazy loading
@@ -162,7 +164,10 @@ ip.Const["RESOURCE"] = "cupy"  # <- globally use GPU
 
 ### Seamless interface between `napari`
 
-[napari](https://github.com/napari/napari) is an interactive viewer for multi-dimensional images. `impy` has a **simple and efficient interface** with it, via the object `ip.gui`. Since `ImgArray` is tagged with image metadata, you don't have to care about axes or scales. Just run
+[napari](https://github.com/napari/napari) is an interactive viewer for multi-dimensional
+images. `impy` has a **simple and efficient interface** with it, via the object `ip.gui`. 
+Since `ImgArray` is tagged with image metadata, you don't have to care about axes or 
+scales. Just run
 
 ```python
 ip.gui.add(img)

{impy_array-2.4.1 → impy_array-2.4.3}/README.md

@@ -48,8 +48,9 @@ or where to save the image. As a result, **your code will be very concise**:
 import impy as ip
 import numpy as np
 
-img = ip.imread("path/to/image")       # Read images with metadata.
+img = ip.imread("path/to/image.tif")   # Read images with metadata.
 img["z=3;t=0"].imshow()                # Plot image slice at z=3 and t=0.
+img["y=N//4:N//4*3"].imshow()          # `N` for the size of the axis.
 img_fil = img.gaussian_filter(sigma=2) # Paralell batch denoising. No more for loop!
 img_prj = np.max(img_fil, axis="z")    # Z-projection (numpy is aware of image axes!).
 img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend time on searching for the directory!
@@ -62,6 +63,7 @@ img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend tim
 - Tiff file (".tif", ".tiff")
 - MRC file (".mrc", ".rec", ".st", ".map", ".map.gz")
 - Zarr file (".zarr")
+- ND2 file (".nd2")
 - Other image file (".png", ".jpg")
 
 ### Lazy loading
@@ -90,7 +92,10 @@ ip.Const["RESOURCE"] = "cupy"  # <- globally use GPU
 
 ### Seamless interface between `napari`
 
-[napari](https://github.com/napari/napari) is an interactive viewer for multi-dimensional images. `impy` has a **simple and efficient interface** with it, via the object `ip.gui`. Since `ImgArray` is tagged with image metadata, you don't have to care about axes or scales. Just run
+[napari](https://github.com/napari/napari) is an interactive viewer for multi-dimensional
+images. `impy` has a **simple and efficient interface** with it, via the object `ip.gui`. 
+Since `ImgArray` is tagged with image metadata, you don't have to care about axes or 
+scales. Just run
 
 ```python
 ip.gui.add(img)

{impy_array-2.4.1 → impy_array-2.4.3}/impy/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.4.1"
+__version__ = "2.4.3"
 __author__ = "Hanjin Liu"
 __email__ = "liuhanjin-sc@g.ecc.u-tokyo.ac.jp"
 

{impy_array-2.4.1 → impy_array-2.4.3}/impy/arrays/_imshow.py

@@ -177,4 +177,33 @@ def _imshow_matplotlib(self: LabeledArray, label, dims, **kwargs) -> LabeledArra
 def _imshow_ipywidgets(arr: LabeledArray, label: bool, dims, **kwargs) -> LabeledArray:
     from ipywidgets import interact
     
-    raise NotImplementedError()
+    raise NotImplementedError()
+
+@register("ndv")
+def _imshow_ndv(self: LabeledArray, label: bool, dims, **kwargs) -> LabeledArray:
+    from ndv import NDViewer
+    
+    app, should_exec = _get_app()
+    if "c" in self.axes:
+        channel_axis = self.axes.index("c")
+    else:
+        channel_axis = None
+    viewer = NDViewer(self, channel_axis=channel_axis)
+    viewer.show()
+    if should_exec:
+        app.exec()
+    return self
+
+def _get_app():
+    # ported from ndv
+    import sys
+    from qtpy.QtWidgets import QApplication
+
+    is_ipython = False
+    if (app := QApplication.instance()) is None:
+        app = QApplication([])
+        app.setApplicationName("ndv")
+    elif (ipy := sys.modules.get("IPython")) and (shell := ipy.get_ipython()):
+        is_ipython = str(shell.active_eventloop).startswith("qt")
+
+    return app, not is_ipython

{impy_array-2.4.1 → impy_array-2.4.3}/impy/arrays/_utils/_glcm.py

@@ -130,4 +130,4 @@ def check_glcm(self, bins, rescale_max):
         raise ValueError(f"`bins` must be a divisor of {imax+1} (max value of {self.dtype}).")
     self = self // ((imax+1) // bins)
 
-    return self, bins, rescale_max
+    return self, bins, rescale_max

{impy_array-2.4.1 → impy_array-2.4.3}/impy/arrays/_utils/_structures.py

@@ -37,4 +37,4 @@ def ball_like_odd(radius, ndim):
     l = xc*2 + 1
     coords = xp.indices((l,)*ndim)
     s = xp.sum((a-xc)**2 for a in coords)
-    return xp.array(s <= radius*radius, dtype=bool)
+    return xp.array(s <= radius*radius, dtype=bool)

{impy_array-2.4.1 → impy_array-2.4.3}/impy/arrays/bases/metaarray.py

@@ -119,7 +119,7 @@ class MetaArray(AxesMixin, np.ndarray):
         return self.axes.tuple(super().shape)
     
     def __getitem__(self, key: SupportSlicing) -> Self:
-        key = slicer.solve_slicer(key, self.axes)
+        key = slicer.solve_slicer(key, self.axes, self.shape)
 
         if isinstance(key, np.ndarray):
             key = self._broadcast(key)
@@ -133,7 +133,7 @@ class MetaArray(AxesMixin, np.ndarray):
         return out
     
     def __setitem__(self, key: SupportSlicing, value):
-        key = slicer.solve_slicer(key, self.axes)
+        key = slicer.solve_slicer(key, self.axes, self.shape)
         
         if isinstance(key, MetaArray) and key.dtype == bool:
             key = axesop.add_axes(self.axes, self.shape, key, key.axes)
@@ -181,7 +181,7 @@ class MetaArray(AxesMixin, np.ndarray):
         if indexer is not None:
             kwargs.update(indexer)
 
-        key = slicer.solve_slicer(kwargs, self.axes)
+        key = slicer.solve_slicer(kwargs, self.axes, self.shape)
         out = super().__getitem__(key)  # get item as np.ndarray
         
         if isinstance(out, self.__class__):  # cannot set attribution to such as numpy.int32 

{impy_array-2.4.1 → impy_array-2.4.3}/impy/arrays/imgarray.py

@@ -6,13 +6,13 @@ from functools import partial
 from scipy import ndimage as ndi
 from typing import TYPE_CHECKING, Literal, Sequence, Iterable, Callable, overload, Any
 
-from .labeledarray import LabeledArray
-from .label import Label
-from .phasearray import PhaseArray
-from .specials import PropArray
-from .tiled import TiledAccessor
+from impy.arrays.labeledarray import LabeledArray
+from impy.arrays.label import Label
+from impy.arrays.phasearray import PhaseArray
+from impy.arrays.specials import PropArray
+from impy.arrays.tiled import TiledAccessor
 
-from ._utils import _filters, _linalg, _deconv, _misc, _glcm, _docs, _transform, _structures, _corr
+from impy.arrays._utils import _filters, _linalg, _deconv, _misc, _glcm, _docs, _transform, _structures, _corr
 
 from impy.arrays.bases.metaarray import _NoValue
 from impy.utils.axesop import add_axes, switch_slice, complement_axes, find_first_appeared
@@ -217,6 +217,44 @@ class ImgArray(LabeledArray):
             c_axes=complement_axes(dims, self.axes),
             kwargs=dict(matrix=mx, order=order, mode=mode, cval=cval),
         )
+    
+    @_docs.write_docs
+    @dims_to_spatial_axes
+    @same_dtype(asfloat=True)
+    @check_input_and_output
+    def shift(
+        self, translation, order: int = 3, mode: PaddingMode = "constant", 
+        cval: float = 0, prefilter: bool | None = None, dims: Dims = None,
+        update: bool = False,
+    ) -> ImgArray:
+        """
+        2D stretching of an image from a point.
+
+        Parameters
+        ----------
+        translation : array-like
+            Translation in pixels. Must match the length of spatial dimensions.
+        {mode}{cval}{dims}{order}
+
+        Returns
+        -------
+        ImgArray
+            Stretched image.
+        """
+        if isinstance(cval, str) and hasattr(np, cval):
+            cval = getattr(np, cval)(self.value)
+        elif callable(cval):
+            cval = cval(self.value)
+
+        prefilter = prefilter or order > 1
+        mtx = _transform.compose_affine_matrix(translation=translation)
+
+        return self._apply_dask(
+            _transform.warp,
+            c_axes=complement_axes(dims, self.axes),
+            kwargs=dict(matrix=mtx, order=order, mode=mode, cval=cval,
+                        prefilter=prefilter)
+        )
 
     @_docs.write_docs
     @dims_to_spatial_axes
@@ -2836,7 +2874,7 @@ class ImgArray(LabeledArray):
         if key is None:
             slices = (slice(None),) * ndim
         else:
-            slices = solve_slicer(key, Axes(dims))
+            slices = solve_slicer(key, Axes(dims), self.shape)
         dtype = np.complex128 if double_precision else np.complex64
 
         # Calculate exp(-ikx)
@@ -3957,8 +3995,8 @@ class ImgArray(LabeledArray):
     @check_input_and_output
     def drift_correction(
         self,
-        shift: Coords = None,
-        ref: ImgArray = None,
+        shift: Coords | None = None,
+        ref: ImgArray | Any | None = None,
         *,
         zero_ave: bool = True,
         along: AxisLike | None = None,
@@ -3977,8 +4015,10 @@ class ImgArray(LabeledArray):
         shift : DataFrame or (N, D) array, optional
             Translation vectors. If DataFrame, it must have columns named with all the symbols
             contained in ``dims``.
-        ref : ImgArray, optional
-            The reference n-D image to determine drift, if ``shift`` was not given.
+        ref : ImgArray or slicer, optional
+            The reference n-D image to determine drift, if ``shift`` was not given. This
+            parameter can be a slicer, which will be used to slice the image to make a
+            reference.
         zero_ave : bool, default is True
             If True, average shift will be zero.
         along : AxisLike, optional
@@ -4008,7 +4048,7 @@ class ImgArray(LabeledArray):
             if ref is None:
                 ref = self
             elif not isinstance(ref, ImgArray):
-                raise TypeError(f"'ref' must be an ImgArray object, but got {type(ref)}")
+                ref = self[ref]
             if ref.axes != [along] + dims:
                 from itertools import product
                 _c_axes = complement_axes([along] + dims, str(ref.axes))

{impy_array-2.4.1 → impy_array-2.4.3}/impy/arrays/lazy.py

@@ -129,7 +129,7 @@ class LazyImgArray(AxesMixin):
         return xp.asnumpy(self.value.compute())
     
     def __getitem__(self, key):
-        key = slicer.solve_slicer(key, self.axes)
+        key = slicer.solve_slicer(key, self.axes, self.shape)
             
         new_axes = slice_axes(self.axes, key)
         out = self.__class__(
@@ -281,6 +281,12 @@ class LazyImgArray(AxesMixin):
         chunk_info = ", ".join([f"{s}({o})" for s, o in zip(self.chunksize, self.axes)])
         return chunk_info
     
+    def astype(self, dtype: DTypeLike, copy: bool = True) -> LazyImgArray:
+        """Convert the array to the specified data type."""
+        out = self.__class__(self.value.astype(dtype, copy=copy))
+        out._set_info(self)
+        return out
+    
     def _repr_dict_(self):
         return {
             "name": self.name,
@@ -555,9 +561,9 @@ class LazyImgArray(AxesMixin):
             dtype = self.dtype
         all_axes = str(self.axes)
         def _func(input: xp.ndarray, *args, **kwargs):
-            out = xp.empty(input.shape, input.dtype)
+            out = xp.empty(input.shape, dtype=dtype)
             for sl in iter_slice(input.shape, c_axes, all_axes):
-                out[sl] = func(input[sl], *args, **kwargs)
+                out[sl] = func(input[sl], *args, **kwargs).astype(dtype, copy=False)
             return out
         depth = switch_slice(c_axes, self.axes, 0, depth)
         return da.map_overlap(
@@ -1143,10 +1149,11 @@ class LazyImgArray(AxesMixin):
     @same_dtype(asfloat=True)
     @check_input_and_output_lazy
     @dims_to_spatial_axes
-    def drift_correction(self, shift: Coords = None, ref: ImgArray = None, *, 
-                         zero_ave: bool = True, along: str = None, dims: Dims = 2, 
-                         update: bool = False, **affine_kwargs) -> LazyImgArray:
-        
+    def drift_correction(
+        self, shift: Coords | None = None, ref: ImgArray | Any | None = None, *, 
+        zero_ave: bool = True, along: str = None, dims: Dims = 2, 
+        update: bool = False, **affine_kwargs,
+    ) -> LazyImgArray:
         if along is None:
             along = find_first_appeared("tpzcia", include=self.axes, exclude=dims)
         elif len(along) != 1:
@@ -1165,8 +1172,8 @@ class LazyImgArray(AxesMixin):
                          UserWarning)
                     dims = _dims
             elif not isinstance(ref, self.__class__):
-                raise TypeError(f"'ref' must be LazyImgArray object, but got {type(ref)}")
-            elif ref.axes != along + dims:
+                ref = self[ref]
+            if ref.axes != along + dims:
                 raise ValueError(f"Arguments `along`({along}) + `dims`({dims}) do not match "
                                  f"axes of `ref`({ref.axes})")
 

{impy_array-2.4.1 → impy_array-2.4.3}/impy/arrays/tiled.py

@@ -94,9 +94,12 @@ class TiledImage(Generic[_T]):
             from dask import array as da
             
             input = da.from_array(img.value, chunks=self._chunks)
+            
+            def _func(arr: np.ndarray, *args, **kwargs) -> np.ndarray:
+                return func(arr, *args, **kwargs).astype(arr.dtype, copy=False)
             out: np.ndarray = xp.asnumpy(
                 da.map_overlap(
-                    func, 
+                    _func, 
                     input,
                     *args,
                     depth=self.depth,
@@ -114,6 +117,7 @@ class TiledImage(Generic[_T]):
                 c_axes="",
                 depth=self.depth,
                 boundary=self.boundary, 
+                dtype=img.dtype,
                 args=args,
                 kwargs=kwargs,
             )

{impy_array-2.4.1 → impy_array-2.4.3}/impy/core.py

@@ -121,8 +121,11 @@ def array(
             dtype = arr.dtype
     
     axes, name = _normalize_params(axes, name, like)
-        
-    _arr = np.array(arr, dtype=dtype, copy=copy)
+    
+    if copy:
+        _arr = np.array(arr, dtype=dtype)
+    else:
+        _arr = np.asarray(arr, dtype=dtype)
     
     # Automatically determine axes
     if axes is None:
@@ -567,7 +570,7 @@ def imread(
         scale_unit = {a: scale_unit for a in "zyx"}
         
     if is_memmap and axes is not None:
-        sl = solve_slicer(key, Axes(axes))
+        sl = solve_slicer(key, Axes(axes), img.shape)
         axes = "".join(a for a, k in zip(axes, sl) if not isinstance(k, int))
         img = np.asarray(img[sl], dtype=dtype)
     

{impy_array-2.4.1 → impy_array-2.4.3}/impy/correlation.py

@@ -817,8 +817,8 @@ def manders_coloc(
     
     :math:`r = \frac{\sum_{i \in I_{ref}} I_i}{\sum_{i} I_i}`
     
-    This value is NOT independent of background intensity. You need to correctly subtract
-    background from self. This value is NOT interchangable between channels.
+    This value is NOT independent of background intensity. You need to correctly 
+    subtract background from self. This value is NOT interchangable between channels.
     
     Parameters
     ----------
@@ -832,13 +832,19 @@ def manders_coloc(
         Correlation coefficient(s).
     """        
     if img1.dtype != bool:
-        raise TypeError("`ref` must be a binary image.")
+        raise TypeError("`img1` must be a binary image.")
     if img0.shape != img1.shape:
         raise ValueError(f"Shape mismatch. `img0` has shape {img0.shape} but `img1` "
                          f"has shape {img1.shape}")
-    if img0.axes != img1.axes:
-        warn(f"Axes mismatch. `img0` has axes {img0.axes} but `img1` has axes {img1.axes}. "
-              "Result may be wrong due to this mismatch.", UserWarning)
+    if not isinstance(img1, ImgArray):
+        img1 = ip_asarray(img1, axes=img0.axes)
+    elif img0.axes != img1.axes:
+        warn(
+            f"Axes mismatch. `img0` has axes {img0.axes} but `img1` has axes "
+            f"{img1.axes}. Result may be wrong due to this mismatch.",
+            UserWarning,
+            stacklevel=2,
+        )
     img0 = img0.as_float()
     total = np.sum(img0, axis=dims)
     img0 = img0.copy()

{impy_array-2.4.1 → impy_array-2.4.3}/impy/io.py

@@ -365,8 +365,9 @@ def _(path: str, memmap: bool = False) -> ImageData:
 @IO.mark_writer(".tif", ".tiff")
 def _(path: str, img: ImpyArray, lazy: bool = False):
     """The TIFF writer."""
+    from tifffile import imwrite, memmap
+
     if lazy:
-        from tifffile import memmap
         from dask import array as da
         kwargs = _get_ijmeta_from_img(img, update_lut=False)
         mmap = memmap(str(path), shape=img.shape, dtype=img.dtype, **kwargs)
@@ -375,7 +376,6 @@ def _(path: str, img: ImpyArray, lazy: bool = False):
         da.store(img_dask, writer)
         return
 
-    from tifffile import imwrite
     rest_axes = complement_axes(img.axes, "tzcyx")
     new_axes = ""
     for a in img.axes:
@@ -394,11 +394,11 @@ def _(path: str, img: ImpyArray, lazy: bool = False):
         img_new.set_scale(img)
         img = img_new
 
-        warnings.warn("Image axes changed", UserWarning, stacklevel=2)
+        warnings.warn(f"Image axes changed", UserWarning, stacklevel=2)
 
     img = img.sort_axes()
     if img.dtype == "bool":
-        img = img.astype(np.uint8)
+        img = img.astype(np.uint8)  # tif does not support bool
     imsave_kwargs = _get_ijmeta_from_img(img, update_lut=True)
     imwrite(path, img, **imsave_kwargs)
     return None

{impy_array-2.4.1 → impy_array-2.4.3}/impy/utils/gauss.py

@@ -156,4 +156,4 @@ class GaussianBackground(DiagonalGaussian):
         self.sg = np.array(data.shape, dtype="float32")
         self.b, p95 = np.percentile(data, [5, 95])
         self.a = p95 - self.b
-        return None
+        return None

impy_array-2.4.3/impy/utils/slicer.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from functools import lru_cache
+import math
+from typing import Any, Mapping
+from impy._types import Slices
+from impy.axes import Slicer, Axes
+
+__all__ = ["str_to_slice", "solve_slicer"]
+
+class _Slicer(ABC):
+    def str_to_slice(self, v: str) -> list[int] | slice | int:
+        v = v.replace(" ", "")
+        if "," in v:
+            sl = sum((self._range_to_list(v) for v in v.split(",")), [])
+        elif ":" in v:
+            sl = slice(*map(self._int_or_none, v.split(":")))
+        else:
+            sl = self._int(v)
+        return sl
+    
+    def _range_to_list(self, v: str) -> list[int]:    
+        if ":" in v:
+            s, e = v.split(":")
+            return list(range(self._int(s), self._int(e)))
+        else:
+            return [self._int(v)]
+
+    def _int_or_none(self, v: str) -> int | None:
+        if v:
+            return self._int(v)
+        else:
+            return None
+
+    @abstractmethod
+    def _int(self, v: str) -> int:
+        """Convert a string to an integer."""
+
+    
+def str_to_slice(v: str) -> list[int] | slice | int:
+    return ConstSlicer().str_to_slice(v)
+
+class ConstSlicer(_Slicer):
+    def _int(self, v: str) -> int:
+        return int(v)
+
+class EvalSlicer(_Slicer):
+    def __init__(self, size: int):
+        self._size = size
+
+    def _int(self, v: str) -> int:
+        ns = {
+            "N": self._size,
+            "int": int,
+            "ceil": math.ceil,
+            "floor": math.floor,
+            "round": round,
+            "__builtins__": {},
+        }
+        out = eval(v, ns)
+        if not hasattr(out, "__index__"):
+            raise ValueError(f"Invalid index: {v!r}.")
+        return out.__index__()
+
+
+def axis_targeted_slicing(
+    axes: tuple[str, ...], 
+    string: str,
+    shape: tuple[int, ...] | None = None,
+) -> Slices:
+    """
+    Make a conventional slices from an axis-targeted slicing string.
+
+    Parameters
+    ----------
+    axes : str
+        Axes of input ndarray.
+    string : str
+        Axis-targeted slicing string. If an axis that does not exist in `axes` is
+        contained, this function will raise ValueError.
+
+    Returns
+    -------
+    slices
+    """    
+    if "N" in string:
+        return axis_targeted_slicing_eval(axes, string, shape)
+    else:
+        return axis_targeted_slicing_const(axes, string)
+
+@lru_cache
+def axis_targeted_slicing_const(axes: tuple[str, ...], string: str) -> Slices:
+    keylist = string.replace(" ", "").split(";")
+    dict_slicer: dict[str, Any] = {}
+    
+    for k in keylist:
+        if k.count("=") != 1:
+            raise ValueError(f"Informal axis-targeted slicing: {k!r}.")
+        axis, sl_str = k.split("=")
+        try:
+            sl = str_to_slice(sl_str)
+        except ValueError:
+            raise ValueError(f"Informal axis-targeted slicing: {k!r}.")
+        else:
+            dict_slicer[axis] = sl
+    
+    return _dict_to_slice(dict_slicer, axes)
+
+def axis_targeted_slicing_eval(
+    axes: tuple[str, ...], 
+    string: str, 
+    shape: tuple[int, ...] | None = None,
+) -> Slices:
+    keylist = string.replace(" ", "").split(";")
+    dict_slicer: dict[str, Any] = {}
+    
+    for k in keylist:
+        if k.count("=") != 1:
+            raise ValueError(f"Informal axis-targeted slicing: {k!r}.")
+        axis, sl_str = k.split("=")
+        try:
+            size = shape[axes.index(axis)]
+            sl = EvalSlicer(size).str_to_slice(sl_str)
+        except ValueError:
+            raise ValueError(f"Informal axis-targeted slicing: {k!r}.")
+        else:
+            dict_slicer[axis] = sl
+    
+    return _dict_to_slice(dict_slicer, axes)
+
+def _dict_to_slice(sl: dict[str, Any], axes: tuple[str, ...]):
+    sl_list = [slice(None)] * len(axes)
+    
+    for k, v in sl.items():
+        idx = axes.index(k)
+        sl_list[idx] = v
+    
+    return tuple(sl_list)
+
+def solve_slicer(key: Any, axes: Axes, shape: tuple[int, ...] | None = None) -> Slices:
+    if isinstance(key, str):
+        key = axis_targeted_slicing(tuple(axes), key, shape)
+    
+    elif isinstance(key, (Mapping, Slicer)):
+        key = axes.create_slice(key)
+    
+    return key

impy_array-2.4.1/impy/utils/slicer.py

@@ -1,89 +0,0 @@
-from __future__ import annotations
-import re
-from functools import lru_cache
-from typing import Any, Mapping
-from .._types import Slices
-from ..axes import Slicer, Axes
-
-__all__ = ["str_to_slice", "axis_targeted_slicing", "solve_slicer"]
-
-def _range_to_list(v: str) -> list[int]:
-    """
-    "1,3,5" -> [1,3,5]
-    "2,4:6,9" -> [2,4,5,6,9]
-    """
-    if ":" in v:
-        s, e = v.split(":")
-        return list(range(int(s), int(e)))
-    else:
-        return [int(v)]
-
-def _int_or_none(v: str) -> int | None:
-    if v:
-        return int(v)
-    else:
-        return None
-    
-def str_to_slice(v: str) -> list[int] | slice | int:
-    v = re.sub(" ", "", v)
-    if "," in v:
-        sl = sum((_range_to_list(v) for v in v.split(",")), [])
-    elif ":" in v:
-        sl = slice(*map(_int_or_none, v.split(":")))
-    else:
-        sl = int(v)
-    return sl
-
-
-@lru_cache
-def axis_targeted_slicing(axes: tuple[str, ...], string: str) -> Slices:
-    """
-    Make a conventional slices from an axis-targeted slicing string.
-
-    Parameters
-    ----------
-    ndim : int
-        Number of dimension of the array which will be sliced.
-    axes : str
-        Axes of input ndarray.
-    string : str
-        Axis-targeted slicing string. If an axis that does not exist in `axes` is
-        contained, this function will raise ValueError.
-
-    Returns
-    -------
-    slices
-    """    
-    keylist = re.sub(" ", "", string).split(";")
-    dict_slicer: dict[str, Any] = {}
-    
-    for k in keylist:
-        if k.count("=") != 1:
-            raise ValueError(f"Informal axis-targeted slicing: {k!r}.")
-        axis, sl_str = k.split("=")
-        try:
-            sl = str_to_slice(sl_str)
-        except ValueError:
-            raise ValueError(f"Informal axis-targeted slicing: {k!r}.")
-        else:
-            dict_slicer[axis] = sl
-    
-    return dict_to_slice(dict_slicer, axes)
-
-def dict_to_slice(sl: dict[str, Any], axes: tuple[str, ...]):
-    sl_list = [slice(None)] * len(axes)
-    
-    for k, v in sl.items():
-        idx = axes.index(k)
-        sl_list[idx] = v
-    
-    return tuple(sl_list)
-
-def solve_slicer(key: Any, axes: Axes) -> Slices:
-    if isinstance(key, str):
-        key = axis_targeted_slicing(tuple(axes), key)
-    
-    elif isinstance(key, (Mapping, Slicer)):
-        key = axes.create_slice(key)
-    
-    return key