timelined_array 0.0.12__tar.gz → 0.0.13__tar.gz

{timelined_array-0.0.12 → timelined_array-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: timelined_array
-Version: 0.0.12
+Version: 0.0.13
 Summary: Manage easily 1 or multidimensionnal samples numpy arrays that are time related. Extends numpy without removing any of it's abilities on such arrays.
 Author-Email: Timothe Jost <timothe.jost@wanadoo.fr>
 License: MIT
@@ -12,6 +12,10 @@ Description-Content-Type: text/markdown
 
 # timelined_array
 
+![Publish Status](https://github.com/JostTim/timelined_array/actions/workflows/publish.yml/badge.svg)
+![Test Status](https://github.com/JostTim/timelined_array/actions/workflows/test.yml/badge.svg)
+[![codecov](https://codecov.io/gh/JostTim/timelined_array/branch/main/graph/badge.svg)](https://codecov.io/gh/JostTim/timelined_array)
+
 ## Overview
 The TimelinedArray package provides a set of classes and utilities for working with time-indexed arrays. It extends the functionality of NumPy arrays to include time-based indexing and operations, making it easier to work with time-series data.
 

{timelined_array-0.0.12 → timelined_array-0.0.13}/README.md

@@ -1,5 +1,9 @@
 # timelined_array
 
+![Publish Status](https://github.com/JostTim/timelined_array/actions/workflows/publish.yml/badge.svg)
+![Test Status](https://github.com/JostTim/timelined_array/actions/workflows/test.yml/badge.svg)
+[![codecov](https://codecov.io/gh/JostTim/timelined_array/branch/main/graph/badge.svg)](https://codecov.io/gh/JostTim/timelined_array)
+
 ## Overview
 The TimelinedArray package provides a set of classes and utilities for working with time-indexed arrays. It extends the functionality of NumPy arrays to include time-based indexing and operations, making it easier to work with time-series data.
 

{timelined_array-0.0.12 → timelined_array-0.0.13}/pyproject.toml

@@ -10,7 +10,7 @@ dependencies = [
 requires-python = ">=3.11"
 readme = "README.md"
 dynamic = []
-version = "0.0.12"
+version = "0.0.13"
 
 [project.license]
 text = "MIT"
@@ -31,3 +31,15 @@ distribution = true
 [tool.pdm.version]
 source = "file"
 path = "src/timelined_array/__init__.py"
+
+[tool.pdm.dev-dependencies]
+dev = [
+    "pytest>=8.3.2",
+    "pytest-cov>=5.0.0",
+]
+
+[tool.pytest.ini_options]
+addopts = "--pdbcls=IPython.terminal.debugger:TerminalPdb --cov-report html --cov --junitxml=pytest_results.xml"
+testpaths = [
+    "tests",
+]

{timelined_array-0.0.12 → timelined_array-0.0.13}/src/timelined_array/__init__.py

@@ -1,3 +1,3 @@
-__version__ = "0.0.12"
+__version__ = "0.0.13"
 
 from .time import TimelinedArray, MaskedTimelinedArray, Timeline

{timelined_array-0.0.12 → timelined_array-0.0.13}/src/timelined_array/time.py

@@ -260,7 +260,8 @@ class TimeIndexer:
         iindex_time = self.time_to_index(index)
         full_iindex = self._insert_time_index(iindex_time)
         # print("new full index : ",iindex_time)
-        logger.debug(f"About to index over time with iindex_time {iindex_time} and full_iindex {full_iindex}")
+        logger.debug(
+            f"About to index over time with iindex_time {iindex_time} and full_iindex {full_iindex}")
         return self.array[full_iindex]
 
     def get_iindex(self, sec_start=None, sec_stop=None, sec_step=None):
@@ -370,7 +371,8 @@ class TimeMixin:
             if axis < self.time_dimension:
                 final_time_dimension -= 1
             elif axis == self.time_dimension:
-                raise ValueError("The time dimension would simply be discarded after axis removal")
+                raise ValueError(
+                    "The time dimension would simply be discarded after axis removal")
 
         return final_time_dimension
 
@@ -480,7 +482,8 @@ class TimeMixin:
         # we apply this reshaping to timeline too.
 
         final_timeline = (
-            self.timeline[index[time_dimension_in_index]] if len(index) > time_dimension_in_index else self.timeline
+            self.timeline[index[time_dimension_in_index]] if len(
+                index) > time_dimension_in_index else self.timeline
         )
 
         return index, final_timeline, final_time_dimension
@@ -533,7 +536,8 @@ class TimeMixin:
             return result.item()
         if self._time_dimension_in_axis(axis):
             return np.asarray(result)
-        result.time_dimension = self._get_time_dimension_after_axis_removal(axis)
+        result.time_dimension = self._get_time_dimension_after_axis_removal(
+            axis)
         return result
 
     # # REDUCE and SETSTATE are used to instanciate the array from and to a pickled serialized object.
@@ -545,7 +549,8 @@ class TimeMixin:
         # Get the parent's __reduce__ tuple
         pickled_state = super().__reduce__()
         # Create our own tuple to pass to __setstate__
-        new_state = pickled_state[2] + (self.timeline, self.time_dimension)  # type: ignore
+        # type: ignore
+        new_state = pickled_state[2] + (self.timeline, self.time_dimension)
 
         # self.logger.debug(f"Reduced to : time_dimension={self.time_dimension}. Array shape is : {new_state}")
         # Return a tuple that replaces the parent's __setstate__ tuple with our own
@@ -656,7 +661,8 @@ class TimeMixin:
                 indexer.append(slice(None))
         indexer = tuple(indexer)
 
-        shift_area = self.itime.__getitem__(period) if time_period else self.__getitem__(period)
+        shift_area = self.itime.__getitem__(
+            period) if time_period else self.__getitem__(period)
 
         # if not this : we lost a dimension because we sliced one axis to a single element, no need to no .mean
         if not len(shift_area.shape) < len(self.shape):
@@ -678,7 +684,8 @@ class TimeMixin:
         # we re-instanciate a TimelinedArray with view instead of the full constructor : faster
         cls = self._get_array_cls()
 
-        swapped_array: TimeCompatibleProtocol = np.swapaxes(np.asarray(self), axis1, axis2).view(cls)  # type: ignore
+        swapped_array: TimeCompatibleProtocol = np.swapaxes(
+            np.asarray(self), axis1, axis2).view(cls)  # type: ignore
         swapped_array.timeline = self.timeline
 
         if axis1 == self.time_dimension:
@@ -707,7 +714,8 @@ class TimeMixin:
         cls = self._get_array_cls()
 
         # we re-instanciate a TimelinedArray with view instead of the full constructor : faster
-        transposed_array: TimeCompatibleProtocol = np.transpose(np.asarray(self), axes).view(cls)  # type: ignore
+        transposed_array: TimeCompatibleProtocol = np.transpose(
+            np.asarray(self), axes).view(cls)  # type: ignore
         transposed_array.timeline = self.timeline
 
         if self.time_dimension in axes:
@@ -780,24 +788,36 @@ class TimeMixin:
         # we re-instanciate a TimelinedArray with view instead of the full constructor : faster
         cls = self._get_array_cls()
 
-        rolled_array: TimeCompatibleProtocol = np.rollaxis(np.asarray(self), axis, start).view(cls)  # type: ignore
+        rolled_array: TimeCompatibleProtocol = np.rollaxis(
+            np.asarray(self), axis, start).view(cls)  # type: ignore
+
+        # reinject timeline as is
         rolled_array.timeline = self.timeline
-        rolled_array.time_dimension = self.time_dimension
-
-        if axis < self.time_dimension:
-            if start <= axis:
-                rolled_array.time_dimension += 1
-            elif start <= self.time_dimension:
-                rolled_array.time_dimension -= 1
-        elif axis == self.time_dimension:
-            rolled_array.time_dimension = start
-        else:
-            if start <= self.time_dimension:
-                rolled_array.time_dimension -= 1
-            elif start > self.time_dimension:
-                rolled_array.time_dimension += 1
 
-        # TimelinedArray.time_dimension and TimelinedArray.timeline are set. good to go
+        # then fix the time_position according to the rolled axis
+
+        def rollaxis_mapping(shape, axis, start=0):
+            n = len(shape)
+            if axis < 0:
+                axis += n
+            if start < 0:
+                start += n
+            if not (0 <= axis < n and 0 <= start <= n):
+                raise ValueError("axis and start must be within valid range")
+            new_order = list(range(n))
+
+            axis_value = new_order.pop(axis)
+
+            if start > axis:
+                new_order.insert(start - 1, axis_value)
+            else:
+                new_order.insert(start, axis_value)
+            mapping = {i: new_order.index(i) for i in range(n)}
+            return mapping
+
+        rolled_array.time_dimension = rollaxis_mapping(
+            self.shape, axis, start)[self.time_dimension]
+
         return rolled_array
 
     def mean(
@@ -915,7 +935,8 @@ class TimeMixin:
         # returns a modified version of the array, with the first element of the array to time zero,
         # and shift the rest accordingly
         cls = self._get_array_cls()
-        return cls(self, timeline=self.timeline - self.timeline[at])  # type: ignore
+        # type: ignore
+        return cls(self, timeline=self.timeline - self.timeline[at])
 
     def offset_timeline(self, offset):
         """Returns a modified version of the array with time offset.
@@ -983,7 +1004,8 @@ class TimeMixin:
                 break
 
         if timeline is None:
-            raise ValueError("timeline must be supplied if the input_array is not a TimelinedArray")
+            raise ValueError(
+                "timeline must be supplied if the input_array is not a TimelinedArray")
 
         if time_dimension is None:  # same thing for the time dimension.
             time_dimension = getattr(data, "time_dimension", None)
@@ -1134,7 +1156,8 @@ class TimelinedArray(TimeMixin, np.ndarray, TimeCompatibleProtocol):
             logger.debug(f"wrapping array after ufunc {context[0].__name__}")
         output = super().__array_wrap__(out_arr, context)
         if len(output.shape) < len(self.shape):
-            logger.debug(f"shape reduced from : {self.shape} to : {output.shape}. outarray was : {out_arr.shape}")
+            logger.debug(
+                f"shape reduced from : {self.shape} to : {output.shape}. outarray was : {out_arr.shape}")
         return output
 
     def __array_function__(self, func, types, args, kwargs):
@@ -1166,7 +1189,8 @@ class TimelinedArray(TimeMixin, np.ndarray, TimeCompatibleProtocol):
             TimelinedArray | np.ndarray: Indexed result based on the provided index.
         """
 
-        index, final_timeline, final_time_dimension = self._get_indexed_times(index)
+        index, final_timeline, final_time_dimension = self._get_indexed_times(
+            index)
 
         if final_timeline is None or final_time_dimension is None:
             return np.asarray(self).__getitem__(index)
@@ -1302,7 +1326,8 @@ class MaskedTimelinedArray(TimeMixin, np.ma.MaskedArray, TimeCompatibleProtocol)
             MaskedTimelinedArray | np.ma.MaskedArray: The masked array or MaskedTimelinedArray based on the index.
         """
 
-        index, final_timeline, final_time_dimension = self._get_indexed_times(index)
+        index, final_timeline, final_time_dimension = self._get_indexed_times(
+            index)
 
         if final_timeline is None or final_time_dimension is None:
             return np.ma.MaskedArray(data=np.asarray(self), mask=self.mask, fill_value=self.fill_value).__getitem__(

timelined_array-0.0.13/tests/test_timelined_array.py

@@ -0,0 +1,171 @@
+import numpy as np
+import pytest
+from timelined_array import TimelinedArray, MaskedTimelinedArray
+from timelined_array.time import (Timeline,
+                                  StartBoundary,
+                                  StoptBoundary,
+                                  EdgePolicy,
+                                  TimeIndexer,
+                                  TimeMixin,
+                                  TimePacker,
+                                  Seconds)
+
+
+@pytest.fixture
+def timelined_array_1D():
+    return TimelinedArray(np.random.rand(50),
+                          timeline=np.arange(50),
+                          time_dimension=0)
+
+
+@pytest.fixture
+def timelined_array_3D():
+    return TimelinedArray(np.random.rand(25, 50, 75),
+                          timeline=np.arange(50),
+                          time_dimension=1)
+
+
+def get_axis_parameters_3D():
+    # affected_axis, time_dimension, shape
+    # if None, we expect an AttributeError
+    return [
+        (0, 0, (50, 75)),
+        (1, None, (25, 75)),
+        (2, 1, (25, 50)),
+        ((0, 2), 0, (50,)),
+        (None, None, None)
+    ]
+
+
+@pytest.mark.parametrize("shape, timeline_dimension", [
+    ((12,), 0),
+    ((10, 30, 50), 2),
+    ((29, 34, 61, 15, 4), 0)
+])
+def test_ta_array_shape(shape, timeline_dimension):
+    ta_array = TimelinedArray(np.random.rand(*shape),
+                              timeline=np.arange(
+        shape[timeline_dimension]),
+        time_dimension=timeline_dimension)
+
+    assert ta_array.shape == shape
+    assert ta_array.timeline.shape == (shape[timeline_dimension],)
+
+
+def test_timeline_creation():
+    timeline = Timeline(np.arange(10))
+    assert isinstance(timeline, Timeline)
+    assert timeline.max() == 9
+    assert timeline.min() == 0
+
+
+def test_start_boundary():
+    assert StartBoundary.inclusive.value(5, 5)
+    assert not StartBoundary.exclusive.value(5, 5)
+
+
+def test_stop_boundary():
+    assert StoptBoundary.inclusive.value(5, 5)
+    assert not StoptBoundary.exclusive.value(5, 5)
+
+
+def test_edge_policy():
+    assert EdgePolicy.start.value == StartBoundary
+    assert EdgePolicy.stop.value == StoptBoundary
+
+
+def test_time_indexer(timelined_array_1D):
+    indexer = TimeIndexer(timelined_array_1D)
+    assert indexer.time_to_index(5) == 5
+    assert indexer.time_to_index(slice(2, 5)) == slice(2, 5, 1)
+
+
+def test_time_mixin_methods(timelined_array_1D):
+    assert timelined_array_1D.sec_max() == 49
+    assert timelined_array_1D.sec_min() == 0
+
+
+def test_ta_transpose(timelined_array_3D):
+    transposed = timelined_array_3D.transpose(2, 0, 1)
+    assert transposed.shape == (75, 25, 50)
+    assert transposed.time_dimension == 2
+
+
+def test_ta_swapaxes(timelined_array_3D):
+    swapped = timelined_array_3D.swapaxes(1, 2)
+    assert swapped.shape == (25, 75, 50)
+    assert swapped.time_dimension == 2
+
+
+@pytest.mark.parametrize("rolled_axis, end_position, expected_time_position, expected_shape", [
+    (0, 2, 0, (50, 25, 75)),
+    (2, 1, 2, (25, 75, 50)),
+    (1, 3, 2, (25, 75, 50))
+])
+def test_ta_rollaxis(rolled_axis,
+                     end_position,
+                     expected_time_position,
+                     expected_shape,
+                     timelined_array_3D):
+    # roll back the axis
+    rolled = timelined_array_3D.rollaxis(rolled_axis, end_position)
+    assert rolled.shape == expected_shape
+    assert rolled.time_dimension == expected_time_position
+
+
+def axis_affecting_functions_blueprint(timelined_array_3D,
+                                       func,
+                                       affected_axis,
+                                       time_dimension,
+                                       shape):
+    result = func(timelined_array_3D, axis=affected_axis)
+    if time_dimension is None:
+        with pytest.raises(AttributeError):
+            result.time_dimension
+    else:
+        assert result.time_dimension == time_dimension
+
+    if shape is None:
+        with pytest.raises(AttributeError):
+            result.shape
+    else:
+        assert result.shape == shape
+
+
+@pytest.mark.parametrize("affected_axis, time_dimension, shape", get_axis_parameters_3D())
+def test_ta_mean(timelined_array_3D, affected_axis, time_dimension, shape):
+    axis_affecting_functions_blueprint(timelined_array_3D, np.mean,
+                                       affected_axis, time_dimension, shape)
+
+
+@pytest.mark.parametrize("affected_axis, time_dimension, shape", get_axis_parameters_3D())
+def test_ta_sum(timelined_array_3D, affected_axis, time_dimension, shape):
+    axis_affecting_functions_blueprint(timelined_array_3D, np.sum,
+                                       affected_axis, time_dimension, shape)
+
+
+@pytest.mark.parametrize("affected_axis, time_dimension, shape", get_axis_parameters_3D())
+def test_ta_std(timelined_array_3D, affected_axis, time_dimension, shape):
+    axis_affecting_functions_blueprint(timelined_array_3D, np.std,
+                                       affected_axis, time_dimension, shape)
+
+
+@pytest.mark.parametrize("affected_axis, time_dimension, shape", get_axis_parameters_3D())
+def test_ta_var(timelined_array_3D, affected_axis, time_dimension, shape):
+    axis_affecting_functions_blueprint(timelined_array_3D, np.var,
+                                       affected_axis, time_dimension, shape)
+
+
+def test_masked_ta_creation():
+    data = np.random.rand(10, 10)
+    mask = data > 0.5
+    masked_ta = MaskedTimelinedArray(
+        data, mask=mask, timeline=np.arange(10), time_dimension=0)
+    assert isinstance(masked_ta, MaskedTimelinedArray)
+    assert masked_ta.shape == (10, 10)
+    assert masked_ta.time_dimension == 0
+
+
+def test_seconds_to_index():
+    sec = Seconds(10)
+    assert sec.to_index(2) == 20

timelined_array-0.0.12/tests/__init__.py

@@ -1,111 +0,0 @@
-import unittest
-import numpy as np
-from numpy.testing import assert_array_equal
-from timelined_array.time import TimeIndexer, Timeline, TimelinedArray, MaskedTimelinedArray
-
-
-class TestTimeline(unittest.TestCase):
-    def test_timeline_creation(self):
-        timeline = Timeline([0, 1, 2, 3, 4])
-        self.assertEqual(timeline.max(), 4)
-        self.assertEqual(timeline.min(), 0)
-
-    def test_timeline_uniformize(self):
-        with self.assertRaises(NotImplementedError):
-            Timeline._uniformize([0, 1, 2, 3, 4])
-
-    def test_timeline_step(self):
-        timeline = Timeline([0, 1, 2, 3, 4])
-        self.assertEqual(timeline.step, 1)
-
-    def test_timeline_max_step(self):
-        timeline = Timeline([0, 1, 2, 3, 4])
-        self.assertEqual(timeline.max_step, 2)
-
-
-class TestTimeIndexer(unittest.TestCase):
-    def setUp(self):
-        self.timeline = Timeline([0, 1, 2, 3, 4])
-        self.array = TimelinedArray(np.random.rand(5, 5), timeline=self.timeline, time_dimension=0)
-        self.indexer = TimeIndexer(self.array)
-
-    def test_time_to_index(self):
-        self.assertEqual(self.indexer.time_to_index(2), 2)
-
-    def test_get_iindex(self):
-        self.assertEqual(self.indexer.get_iindex(1, 3), slice(1, 3, 1))
-
-
-class TestTimelinedArray(unittest.TestCase):
-    def setUp(self):
-        self.timeline = Timeline([0, 1, 2, 3, 4])
-        self.array = TimelinedArray(np.random.rand(5, 5), timeline=self.timeline, time_dimension=0)
-
-    def test_array_creation(self):
-        self.assertEqual(self.array.shape, (5, 5))
-        self.assertEqual(self.array.timeline.max(), 4)
-        self.assertEqual(self.array.time_dimension, 0)
-
-    def test_array_indexing(self):
-        indexed_array = self.array[1:3]
-        self.assertEqual(indexed_array.shape, (2, 5))
-        self.assertEqual(indexed_array.timeline.min(), 1)
-        self.assertEqual(indexed_array.timeline.max(), 2)
-
-    def test_array_transpose(self):
-        transposed_array = self.array.transpose()
-        self.assertEqual(transposed_array.shape, (5, 5))
-        self.assertEqual(transposed_array.time_dimension, 1)
-
-    def test_array_mean(self):
-        mean_value = self.array.mean(axis=0)
-        self.assertEqual(mean_value.shape, (5,))
-
-
-class TestMaskedTimelinedArray(unittest.TestCase):
-    def setUp(self):
-        self.timeline = Timeline([0, 1, 2, 3, 4])
-        self.data = np.random.rand(5, 5)
-        self.mask = np.zeros((5, 5), dtype=bool)
-        self.mask[0, 0] = True
-        self.array = MaskedTimelinedArray(self.data, mask=self.mask, timeline=self.timeline, time_dimension=0)
-
-    def test_masked_array_creation(self):
-        self.assertEqual(self.array.shape, (5, 5))
-        self.assertEqual(self.array.timeline.max(), 4)
-        self.assertEqual(self.array.time_dimension, 0)
-        self.assertTrue(self.array.mask[0, 0])
-
-    def test_masked_array_indexing(self):
-        indexed_array = self.array[1:3]
-        self.assertEqual(indexed_array.shape, (2, 5))
-        self.assertEqual(indexed_array.timeline.min(), 1)
-        self.assertEqual(indexed_array.timeline.max(), 2)
-
-
-class TestMultidimensionnalIndexing(unittest.TestCase):
-    def setUp(self):
-        dimension = (15, 150, 200, 200)
-        y_dim_scale = 2
-        prime = [
-            [
-                (
-                    np.array(
-                        [
-                            np.roll(np.linspace(phase, phase * 2, num=dimension[3], endpoint=True), shift=r)
-                            for r in np.arange(0, dimension[2] * y_dim_scale, y_dim_scale)
-                        ]
-                    )
-                    * t
-                )
-                for t in np.sin(np.linspace(phase, phase + 2, num=dimension[1]))
-            ]
-            for phase in np.linspace(1, dimension[0], num=dimension[0], endpoint=True)
-        ]
-        prime = np.array(prime)
-        sin = np.sin(prime)
-        self.array = TimelinedArray(sin, time_dimension=1, timeline=np.linspace(-2, 7, num=300))
-
-
-if __name__ == "__main__":
-    unittest.main()