Added tests and workflow, upgraded poetry 2, removed Active storage dependency

Author: dwest77a

.github/workflows/ci.yml

@@ -0,0 +1,29 @@
+name: Automatic Test
+
+on:
+  - push
+  - pull_request
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install Python dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip3 install poetry
+        poetry install
+    - name: Run tests
+      run: poetry run pytest

arraypartition/partition.py

@@ -10,19 +10,21 @@
 from dask.utils import SerializableLock
 from dask.array.core import normalize_chunks
 
-try:
-    from XarrayActive import ActiveChunk
-except:
-    class ActiveChunk:
-        pass
+from typing import Union
 
 class ArrayLike:
     """
     Container class for Array-like behaviour
     """
     description = 'Container class for Array-Like behaviour'
 
-    def __init__(self, shape, units=None, dtype=None, source_shape=None):
+    def __init__(
+            self, 
+            shape: tuple, 
+            units: Union[str,None] = None, 
+            dtype: Union[np.dtype,None] = None,
+            source_shape: Union[tuple,None] = None
+        ):
 
         # Standard parameters to store for array-like behaviour
         self.shape = shape
@@ -180,10 +182,11 @@ def get_kwargs(self):
             'named_dims': self.named_dims
         } | super().get_kwargs()
 
-class ArrayPartition(ActiveChunk, SuperLazyArrayLike):
+class ArrayPartition(SuperLazyArrayLike):
     """
     Complete Array-like object with all proper methods for data retrieval.
-    May include methods from ``XarrayActive.ActiveChunk`` if installed."""
+
+    Overridden in Active-enabled packages."""
 
     description = "Complete Array-like object with all proper methods for data retrieval."
 
@@ -640,48 +643,76 @@ def get_dask_chunks(
 
     return normalize_chunks(fsizes_per_dim, shape=array_space, dtype=dtype)
 
-def combine_slices(shape, extent, newslice):
+def combine_sliced_dim(
+        old: slice, 
+        new: slice,
+        shape: tuple,
+        dim: int
+    ) -> slice:
+    """
+    Combine slices for a given dimension.
+    
+    :param old:     (slice) Current slice applied to the dimension.
+    
+    :param new:     (slice) New slice to be combined with the old slice.
+    
+    :param shape:   (tuple) The shape of the native array, before 
+        application of any slices.
+        
+    :param dim:     (int) Integer index of the dimension in the array.
     """
-    Combine existing ``extent`` attribute with a new set of slices.
 
-    :param newslice:        (tuple) A set of slices to apply to the data 
-        'Super-Lazily', i.e the slices will be combined with existing information
-        and applied later in the process.
+    if isinstance(new, int):
+        new = slice(new, new+1)
 
-    :returns:   The combined set of slices.
-    """
+    ostart = old.start or 0
+    ostop  = old.stop or shape[dim]
+    ostep  = old.step or 1
 
-    if len(newslice) != len(shape):
+    osize = (ostop - ostart)/ostep
 
-        raise ValueError(
-            "Compute chain broken - dimensions have been reduced already."
+    nstart = new.start or 0
+    nstop  = new.stop or shape[dim]
+    nstep  = new.step or 1
+
+    nsize = (nstop - nstart)/nstep
+
+    if nsize > osize:
+        raise IndexError(
+            f'Attempted to slice dimension "{dim}" with new slice "({nstart},{nstop},{nstep})'
+            f'but the dimension size is limited to {osize}.'
         )
+
+    start = ostart + ostep*nstart
+    step  = ostep * nstep
+    stop  = start + step * (nstop - nstart)
 
-    def combine_sliced_dim(old, new, dim):
+    return slice(start, stop, step)
 
-        ostart = old.start or 0
-        ostop  = old.stop or shape[dim]
-        ostep  = old.step or 1
+def combine_slices(
+        shape: tuple[int], 
+        extent: tuple[slice], 
+        newslice: tuple[slice,int]
+    ) -> tuple[slice]:
+    """
+    Combine existing ``extent`` attribute with a new set of slices.
 
-        osize = (ostop - ostart)/ostep
+    :param shape:       (tuple) The native source shape of the array.
 
-        nstart = new.start or 0
-        nstop  = new.stop or shape[dim]
-        nstep  = new.step or 1
+    :param extent:      (tuple) The current set of slices recorded
+        for this data selection but not yet applied.
 
-        nsize = (nstop - nstart)/nstep
+    :param newslice:    (tuple) A set of slices to apply to the data 
+        'Super-Lazily', i.e the slices will be combined with existing information
+        and applied later in the process.
 
-        if nsize > osize:
-            raise IndexError(
-                f'Attempted to slice dimension "{dim}" with new slice "({nstart},{nstop},{nstep})'
-                f'but the dimension size is limited to {osize}.'
-            )
+    :returns:   The combined set of slices.
+    """
 
-        start = ostart + ostep*nstart
-        step  = ostep * nstep
-        stop  = start + step * (nstop - nstart)
-        
-        return slice(start, stop, step)
+    if len(newslice) != len(shape):
+        raise ValueError(
+            "Compute chain broken - dimensions have been reduced already."
+        )
 
     if not extent:
         return newslice
@@ -691,7 +722,24 @@ def combine_sliced_dim(old, new, dim):
                 extent[dim] = combine_sliced_dim(extent[dim], newslice[dim], dim)
         return extent
 
-def normalize_partition_chunks(chunks, shape, dtype, named_dims):
+def normalize_partition_chunks(
+        chunks: dict, 
+        shape: tuple[int], 
+        dtype: np.dtype, 
+        named_dims: list
+    ):
+    """
+    Prepare information for dask to normalise chunks.
+
+    :param chunks:      (dict) Dictionary of named dimensions and their number
+        of partitions across different sources.
+
+    :param shape:       (tuple) The total shape of the array in all dimensions.
+
+    :param dtype:       (np.dtype) The data type for this array.
+
+    :param named_dims:  (list) The set of named dimensions for this array.
+    """
 
     chunk_values = []
 
@@ -704,6 +752,8 @@ def normalize_partition_chunks(chunks, shape, dtype, named_dims):
         except ValueError:
             chunk_values.append(chunks[nd])
 
+    # Construct chunk values for each named dimension
+
     return normalize_chunks(
         chunk_values,
         shape,

arraypartition/tests/test_consistency.py

@@ -0,0 +1,18 @@
+class TestConsistency:
+
+    def test_core(self):
+        from ArrayPartition import (
+            ArrayLike,
+            SuperLazyArrayLike,
+            ArrayPartition,
+            get_chunk_space,
+            get_chunk_shape,
+            get_chunk_positions,
+            get_chunk_extent,
+            get_dask_chunks,
+            combine_sliced_dim,
+            combine_slices,
+            normalize_partition_chunks
+        )
+
+        assert True