timelined_array 0.0.13__tar.gz → 0.1.0__tar.gz

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

@@ -1,21 +1,25 @@
 Metadata-Version: 2.1
 Name: timelined_array
-Version: 0.0.13
+Version: 0.1.0
 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>
+Author-Email: Timothe Jost <44769559+JostTim@users.noreply.github.com>
 License: MIT
 Project-URL: Homepage, https://pypi.org/project/timelined_array/
 Project-URL: Source, https://github.com/JostTim/timelined_array
 Requires-Python: >=3.11
-Requires-Dist: numpy
+Requires-Dist: numpy>=2
 Description-Content-Type: text/markdown
 
 # timelined_array
 
+![Python](https://img.shields.io/badge/python-3.11-blue.svg)
+[![PyPI version](https://badge.fury.io/py/timelined_array.svg)](https://badge.fury.io/py/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)
 
+<!-- eventually, add ?cache-bust=1 to badges url above, and update the value of cache-bust randomly at git commits (or based on the commit name) so that we always see the latest badge produced, and not the cached badge in the browser.-->
+
 ## 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.13 → timelined_array-0.1.0}/README.md

@@ -1,9 +1,13 @@
 # timelined_array
 
+![Python](https://img.shields.io/badge/python-3.11-blue.svg)
+[![PyPI version](https://badge.fury.io/py/timelined_array.svg)](https://badge.fury.io/py/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)
 
+<!-- eventually, add ?cache-bust=1 to badges url above, and update the value of cache-bust randomly at git commits (or based on the commit name) so that we always see the latest badge produced, and not the cached badge in the browser.-->
+
 ## 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.1.0/pyproject.toml

@@ -0,0 +1,84 @@
+[project]
+name = "timelined_array"
+description = "Manage easily 1 or multidimensionnal samples numpy arrays that are time related. Extends numpy without removing any of it's abilities on such arrays."
+authors = [
+    { name = "Timothe Jost", email = "44769559+JostTim@users.noreply.github.com" },
+]
+dependencies = [
+    "numpy>=2",
+]
+requires-python = ">=3.11"
+readme = "README.md"
+dynamic = []
+version = "0.1.0"
+
+[project.license]
+text = "MIT"
+
+[project.urls]
+Homepage = "https://pypi.org/project/timelined_array/"
+Source = "https://github.com/JostTim/timelined_array"
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.pdm]
+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 xml --cov --junitxml=pytest_results.xml"
+testpaths = [
+    "tests",
+]
+
+[tool.black]
+preview = true
+line-length = 120
+
+[tool.flake8]
+max-line-length = 120
+ignore = [
+    "F401",
+    "F403",
+    "F841",
+    "E401",
+    "E265",
+    "E704",
+    "E266",
+    "E203",
+    "E712",
+    "W503",
+    "W605",
+]
+
+[tool.pyright]
+reportGeneralTypeIssues = "information"
+reportOptionalMemberAccess = "information"
+reportMissingImports = "information"
+reportMissingModuleSource = "information"
+reportInvalidStringEscapeSequence = "information"
+reportOptionalOperand = "none"
+reportOptionalSubscript = "none"
+reportOptionalIterable = "none"
+reportAttributeAccessIssue = "information"
+typeCheckingMode = "basic"
+include = [
+    "src",
+    "tests",
+]
+exclude = [
+    "**/__pycache__",
+]

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

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

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

@@ -5,7 +5,9 @@ from logging import getLogger
 from enum import Enum
 import operator
 
-from typing import Tuple, List, Protocol, Type, Callable, Any
+from numpy.typing import NDArray
+from types import MethodType
+from typing import Tuple, List, Protocol, Type, Callable, Any, Optional
 
 OperatorType = Callable[[Any, Any], bool]
 
@@ -177,7 +179,7 @@ class TimeIndexer:
     _start_operation: OperatorType
     _stop_operation: OperatorType
 
-    def __init__(self, array: TimeCompatibleProtocol, start="inclusive", stop="exclusive"):
+    def __init__(self, array: "BaseTimeArray", start="inclusive", stop="exclusive"):
         self.array = array
         self.set_edge_policy(start, stop)
 
@@ -260,8 +262,7 @@ 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):
@@ -331,6 +332,11 @@ class TimeMixin:
     start_policy = "inclusive"
     stop_policy = "exclusive"
 
+    # ndarray inherited
+    ndim: int
+    shape: Tuple[int, ...]
+    __sub__: Callable
+
     def _time_dimension_in_axis(self, axis: int | Tuple[int, ...] | None) -> bool:
         """Check if the time dimension is present in the specified axis.
 
@@ -371,8 +377,7 @@ 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
 
@@ -482,8 +487,7 @@ 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
@@ -505,7 +509,7 @@ class TimeMixin:
         return self._get_slice_indexed_times(index)
 
     @staticmethod
-    def _is_single_element(obj):
+    def _is_single_element(obj: np.ndarray):
         """Check if the input object is a single element.
 
         Args:
@@ -519,27 +523,29 @@ class TimeMixin:
 
     def _finish_axis_removing_operation(
         self, result: "TimelinedArray| MaskedTimelinedArray | np.ndarray | int | float", axis: int | Tuple[int, ...]
-    ) -> "TimelinedArray| MaskedTimelinedArray | np.ndarray | int | float":
+    ) -> "TimelinedArray| MaskedTimelinedArray | np.ndarray | int | float | str":
         """Finish axis removing operation.
 
         Args:
-            result (TimeCompatibleProtocol): The result of the operation.
+            result (BaseTimeArray): The result of the operation.
             axis (int | Tuple[int, ...] | None): The axis or axes to remove.
 
         Returns:
-            TimeCompatibleProtocol: The result after finishing the axis removing operation.
+            BaseTimeArray: The result after finishing the axis removing operation.
         """
 
-        if not isinstance(result, np.ndarray):
+        if not isinstance(result, np.ndarray) or not isinstance(result, TimeMixin):
             return result
         if self._is_single_element(result):
             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
 
+
+class BaseTimeArray(TimeMixin, np.ndarray):
+
     # # REDUCE and SETSTATE are used to instanciate the array from and to a pickled serialized object.
     # # We only need to store and retrieve time_dimension and timeline on top of the array's data
     def __reduce__(self):
@@ -547,7 +553,7 @@ class TimeMixin:
         object with additional attributes 'timeline' and 'time_dimension'."""
 
         # Get the parent's __reduce__ tuple
-        pickled_state = super().__reduce__()
+        pickled_state: Tuple[Any, Any, tuple] = super().__reduce__()  # type: ignore
         # Create our own tuple to pass to __setstate__
         # type: ignore
         new_state = pickled_state[2] + (self.timeline, self.time_dimension)
@@ -556,11 +562,11 @@ class TimeMixin:
         # Return a tuple that replaces the parent's __setstate__ tuple with our own
         return (pickled_state[0], pickled_state[1], new_state)
 
-    def __setstate__(self: TimeCompatibleProtocol, state):
+    def __setstate__(self: "BaseTimeArray", state):
         """Set the state of the object using the provided state tuple.
 
         Args:
-            self (TimeCompatibleProtocol): The TimeCompatibleProtocol object.
+            self (BaseTimeArray): The BaseTimeArray object.
             state: The state tuple containing information to set the object's attributes.
 
         Returns:
@@ -582,11 +588,11 @@ class TimeMixin:
 
         return hash((self.__array__(), self.timeline))  # type: ignore
 
-    def _get_array_cls(self) -> TimeCompatibleProtocol:
+    def _get_array_cls(self) -> "BaseTimeArray":
         """Return the class of the array that is compatible with time operations.
 
         Returns:
-            TimeCompatibleProtocol: The class of the array that is compatible with time operations.
+            BaseTimeArray: The class of the array that is compatible with time operations.
         """
 
         valid_types = [TimelinedArray, TimelinedArray]
@@ -596,7 +602,7 @@ class TimeMixin:
         return np.ndarray  # type: ignore
 
     @property
-    def array_info(self: TimeCompatibleProtocol):
+    def array_info(self: "BaseTimeArray"):
         """Return information about the array.
 
         Returns:
@@ -609,11 +615,12 @@ class TimeMixin:
         )
 
     @property
-    def itime(self: TimeCompatibleProtocol):
-        """Return a TimeIndexer object based on the given TimeCompatibleProtocol object."""
+    def itime(self):
+        """Return a TimeIndexer object based on the given BaseTimeArray object."""
 
         return TimeIndexer(self, self.start_policy, self.stop_policy)
 
+    # backward compatibility
     isec = itime
 
     def align_trace(self, start: float, element_nb: int):
@@ -661,16 +668,21 @@ 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):
             shift_area = shift_area.mean(axis=axis)
 
+        if not isinstance(shift_area, np.ndarray):
+            raise NotImplementedError(
+                "Returning shift_values() of the array when shift area is a scalar value (due to .mean()) "
+                "is not yet implemented"
+            )
+
         return self - np.repeat(shift_area.__getitem__(tuple(indexer)), self.shape[axis], axis=axis)
 
-    def swapaxes(self: TimeCompatibleProtocol, axis1: int, axis2: int):
+    def swapaxes(self: "BaseTimeArray", axis1: int, axis2: int):
         """Swap the two specified axes of the TimelinedArray.
 
         Args:
@@ -678,14 +690,13 @@ class TimeMixin:
             axis2 (int): The second axis to be swapped.
 
         Returns:
-            TimeCompatibleProtocol: A new TimelinedArray with the specified axes swapped.
+            BaseTimeArray: A new TimelinedArray with the specified axes swapped.
         """
 
         # 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: BaseTimeArray = np.swapaxes(np.asarray(self), axis1, axis2).view(cls)  # type: ignore
         swapped_array.timeline = self.timeline
 
         if axis1 == self.time_dimension:
@@ -698,14 +709,14 @@ class TimeMixin:
         # TimelinedArray.time_dimension and TimelinedArray.timeline are set. good to go
         return swapped_array
 
-    def transpose(self: TimeCompatibleProtocol, *axes):
+    def transpose(self, *axes):
         """Transpose the array along the specified axes.
 
         Args:
             *axes: The axes to transpose the array along. If not provided, transposes the array in reverse order.
 
         Returns:
-            TimeCompatibleProtocol: The transposed array with updated timeline and time dimension.
+            BaseTimeArray: The transposed array with updated timeline and time dimension.
         """
 
         if not axes:
@@ -714,8 +725,7 @@ 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: BaseTimeArray = np.transpose(np.asarray(self), axes).view(cls)  # type: ignore
         transposed_array.timeline = self.timeline
 
         if self.time_dimension in axes:
@@ -727,12 +737,12 @@ class TimeMixin:
         return transposed_array
 
     @property
-    def T(self: TimeCompatibleProtocol):
+    def T(self):
         """Transposes the object using the transpose method."""
 
         return self.transpose()
 
-    def moveaxis(self: TimeCompatibleProtocol, source: int | Tuple[int, ...], destination: int | Tuple[int, ...]):
+    def moveaxis(self: "BaseTimeArray", source: int | Tuple[int, ...], destination: int | Tuple[int, ...]):
         """Move the axis of the array to new positions.
 
         Args:
@@ -740,7 +750,7 @@ class TimeMixin:
             destination (int or Tuple[int, ...]): The destination position(s) to move the axis to.
 
         Returns:
-            TimeCompatibleProtocol: A new array with the axis moved to the specified destination.
+            BaseTimeArray: A new array with the axis moved to the specified destination.
 
         Note:
             This method re-instantiates a TimelinedArray with a view instead of the full
@@ -755,9 +765,7 @@ class TimeMixin:
         cls = self._get_array_cls()
 
         # we re-instanciate a TimelinedArray with view instead of the full constructor : faster
-        moved_array: TimeCompatibleProtocol = np.moveaxis(np.asarray(self), source, destination).view(
-            cls
-        )  # type: ignore
+        moved_array: BaseTimeArray = np.moveaxis(np.asarray(self), source, destination).view(cls)  # type: ignore
         moved_array.timeline = self.timeline
         moved_array.time_dimension = self.time_dimension
 
@@ -774,7 +782,7 @@ class TimeMixin:
         # TimelinedArray.time_dimension and TimelinedArray.timeline are set. good to go
         return moved_array
 
-    def rollaxis(self: TimeCompatibleProtocol, axis: int, start: int = 0):
+    def rollaxis(self: "BaseTimeArray", axis: int, start: int = 0):
         """Roll the axis of the TimelinedArray.
 
         Args:
@@ -782,14 +790,13 @@ class TimeMixin:
             start (int, optional): The position where the axis is placed. Defaults to 0.
 
         Returns:
-            TimeCompatibleProtocol: A TimelinedArray with the rolled axis.
+            BaseTimeArray: A TimelinedArray with the rolled axis.
         """
 
         # 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: BaseTimeArray = np.rollaxis(np.asarray(self), axis, start).view(cls)  # type: ignore
 
         # reinject timeline as is
         rolled_array.timeline = self.timeline
@@ -815,14 +822,14 @@ class TimeMixin:
             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]
+        rolled_array.time_dimension = rollaxis_mapping(self.shape, axis, start)[self.time_dimension]
 
         return rolled_array
 
-    def mean(
-        self: TimeCompatibleProtocol, axis: int | Tuple[int, ...] | None = None, dtype=None, out=None, keepdims=False
-    ):
+    def all_axes(self):
+        return tuple([i for i in range(self.ndim)])
+
+    def mean(self, axis: int | Tuple[int, ...] | None = None, dtype=None, out=None, keepdims=False):
         """Calculates the mean along the specified axis.
 
         Args:
@@ -835,14 +842,13 @@ class TimeMixin:
         Returns:
             ndarray: Mean of the input array along the specified axis.
         """
-
+        if axis is None:
+            axis = self.all_axes()
         result = super().mean(axis=axis, dtype=dtype, out=out, keepdims=keepdims)
         return self._finish_axis_removing_operation(result, axis)
 
     # Override other reduction methods similarly if needed
-    def sum(
-        self: TimeCompatibleProtocol, axis: int | Tuple[int, ...] | None = None, dtype=None, out=None, keepdims=False
-    ):
+    def sum(self, axis: int | Tuple[int, ...] | None = None, dtype=None, out=None, keepdims=False):
         """Calculate the sum along the specified axis.
 
         Args:
@@ -861,12 +867,13 @@ class TimeMixin:
         Returns:
             The sum of the input array along the specified axis.
         """
-
+        if axis is None:
+            axis = self.all_axes()
         result = super().sum(axis=axis, dtype=dtype, out=out, keepdims=keepdims)
         return self._finish_axis_removing_operation(result, axis)
 
     def std(
-        self: TimeCompatibleProtocol,
+        self: "BaseTimeArray",
         axis: int | Tuple[int, ...] | None = None,
         dtype=None,
         out=None,
@@ -889,12 +896,13 @@ class TimeMixin:
             ndarray: A new array containing the standard deviation
                 of elements along the specified axis after removing the axis.
         """
-
+        if axis is None:
+            axis = self.all_axes()
         result = super().std(axis=axis, dtype=dtype, out=out, ddof=ddof, keepdims=keepdims)
         return self._finish_axis_removing_operation(result, axis)
 
     def var(
-        self: TimeCompatibleProtocol,
+        self: "BaseTimeArray",
         axis: int | Tuple[int, ...] | None = None,
         dtype=None,
         out=None,
@@ -904,7 +912,7 @@ class TimeMixin:
         """Calculate the variance along the specified axis.
 
         Args:
-            self (TimeCompatibleProtocol): The input data.
+            self (BaseTimeArray): The input data.
             axis (int | Tuple[int, ...] | None): Axis or axes along which the variance is computed.
                 The default is to compute the variance of the flattened array.
             dtype: Data-type of the result. If not provided, the data-type of the input is used.
@@ -918,7 +926,8 @@ class TimeMixin:
         Returns:
             ndarray: A new array containing the variance of the input array along the specified axis.
         """
-
+        if axis is None:
+            axis = self.all_axes()
         result = super().var(axis=axis, dtype=dtype, out=out, ddof=ddof, keepdims=keepdims)
         return self._finish_axis_removing_operation(result, axis)
 
@@ -936,7 +945,7 @@ class TimeMixin:
         # and shift the rest accordingly
         cls = self._get_array_cls()
         # type: ignore
-        return cls(self, timeline=self.timeline - self.timeline[at])
+        return cls(self, timeline=self.timeline - self.timeline[at])  # type: ignore
 
     def offset_timeline(self, offset):
         """Returns a modified version of the array with time offset.
@@ -1004,8 +1013,7 @@ 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)
@@ -1053,7 +1061,7 @@ class TimePacker:
         return iter((self.array.timeline, self.array.__array__()))
 
 
-class TimelinedArray(TimeMixin, np.ndarray, TimeCompatibleProtocol):
+class TimelinedArray(BaseTimeArray):
     """
     The TimelinedArray class is a subclass of the numpy.ndarray class, which represents a multi-dimensional
     array of homogeneous data. This class adds additional functionality
@@ -1085,9 +1093,16 @@ class TimelinedArray(TimeMixin, np.ndarray, TimeCompatibleProtocol):
 
     """
 
+    # backward compatibility
     TA_Timeline = Timeline
 
-    def __new__(cls, data, timeline=None, time_dimension: int | None = None, uniform_space=False) -> "TimelinedArray":
+    def __new__(
+        cls,
+        data,
+        timeline: Optional[Timeline | np.ndarray | list] = None,
+        time_dimension: int | None = None,
+        uniform_space=False,
+    ) -> "TimelinedArray":
         """Create a new TimelinedArray object from the input data.
 
         Args:
@@ -1100,7 +1115,7 @@ class TimelinedArray(TimeMixin, np.ndarray, TimeCompatibleProtocol):
             TimelinedArray: A new TimelinedArray object.
         """
 
-        data, timeline, time_dimension = TimeMixin.extract_time_from_data(
+        data, timeline, time_dimension = BaseTimeArray.extract_time_from_data(
             data, timeline=timeline, time_dimension=time_dimension, uniform_space=uniform_space
         )
 
@@ -1137,7 +1152,12 @@ class TimelinedArray(TimeMixin, np.ndarray, TimeCompatibleProtocol):
         self.timeline = getattr(obj, "timeline", Timeline([]))
         self.time_dimension = getattr(obj, "time_dimension", 0)
 
-    def __array_wrap__(self, out_arr, context=None):
+    def __array_wrap__(
+        self,
+        out_arr,
+        context=None,
+        return_scalar=False,
+    ):
         """Wrap the output array after a ufunc operation.
 
         Args:
@@ -1154,10 +1174,9 @@ class TimelinedArray(TimeMixin, np.ndarray, TimeCompatibleProtocol):
 
         if context is not None:
             logger.debug(f"wrapping array after ufunc {context[0].__name__}")
-        output = super().__array_wrap__(out_arr, context)
+        output = super().__array_wrap__(out_arr, context, return_scalar)
         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):
@@ -1189,8 +1208,7 @@ 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)
@@ -1240,19 +1258,19 @@ class TimelinedArray(TimeMixin, np.ndarray, TimeCompatibleProtocol):
         return TimelinedArray(aligned_arrays)
 
 
-class MaskedTimelinedArray(TimeMixin, np.ma.MaskedArray, TimeCompatibleProtocol):
+class MaskedTimelinedArray(np.ma.MaskedArray, BaseTimeArray):
     def __new__(
         cls,
         data,
-        mask=np.ma.nomask,
+        mask: NDArray[np.bool_] | np.bool_ | bool | np.ma.MaskedArray = np.ma.nomask,
         dtype=None,
         copy=False,
         fill_value=None,
         keep_mask=True,
         hard_mask=False,
         shrink=True,
-        timeline=None,
-        time_dimension=None,
+        timeline: Optional[Timeline | np.ndarray | list] | None = None,
+        time_dimension: Optional[int] = None,
         uniform_space=False,
         **kwargs,
     ):
@@ -1277,7 +1295,7 @@ class MaskedTimelinedArray(TimeMixin, np.ma.MaskedArray, TimeCompatibleProtocol)
             An instance of the class with the specified parameters.
         """
 
-        _, timeline, time_dimension = TimeMixin.extract_time_from_data(
+        _, timeline, time_dimension = BaseTimeArray.extract_time_from_data(
             data, timeline=timeline, time_dimension=time_dimension, uniform_space=uniform_space
         )
 
@@ -1326,8 +1344,7 @@ 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 → timelined_array-0.1.0}/tests/test_timelined_array.py

@@ -1,52 +1,49 @@
 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)
+from timelined_array.time import (
+    Timeline,
+    StartBoundary,
+    StoptBoundary,
+    EdgePolicy,
+    TimeIndexer,
+    TimeMixin,
+    TimePacker,
+    Seconds,
+)
+import pickle
+from pathlib import Path
 
 
 @pytest.fixture
 def timelined_array_1D():
-    return TimelinedArray(np.random.rand(50),
-                          timeline=np.arange(50),
-                          time_dimension=0)
+    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)
+    return TimelinedArray(np.random.rand(25, 50, 75), timeline=np.arange(50), time_dimension=1)
+
+
+@pytest.fixture
+def pickle_path():
+    file_path = Path("serialized_test_3D_ta_array.pickle")
+    yield file_path
+    if file_path.exists():
+        file_path.unlink(missing_ok=True)
 
 
 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)
-])
+    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)
+    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],)
@@ -58,6 +55,25 @@ def test_timeline_creation():
     assert timeline.max() == 9
     assert timeline.min() == 0
 
+    with pytest.raises(NotImplementedError):
+        timeline = Timeline(np.random.rand(10), uniform_space=True)
+    # assert np.unique(np.diff(timeline)).size == 1
+
+
+def test_pickle_unpickle(timelined_array_3D, pickle_path):
+    # Pickle the numpy array
+    with open(pickle_path, "wb") as f:
+        pickle.dump(timelined_array_3D, f)
+
+    # Unpickle the numpy array
+    with open(pickle_path, "rb") as f:
+        unserialized_3D_array = pickle.load(f)
+
+    # Assert that the original and unpickled arrays are the same
+    np.testing.assert_array_equal(timelined_array_3D, unserialized_3D_array)
+    np.testing.assert_array_equal(timelined_array_3D.timeline, unserialized_3D_array.timeline)
+    assert timelined_array_3D.time_dimension == unserialized_3D_array.time_dimension
+
 
 def test_start_boundary():
     assert StartBoundary.inclusive.value(5, 5)
@@ -97,27 +113,18 @@ def test_ta_swapaxes(timelined_array_3D):
     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):
+@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):
+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):
@@ -134,33 +141,28 @@ def axis_affecting_functions_blueprint(timelined_array_3D,
 
 @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)
+    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)
+    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)
+    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)
+    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)
+    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

timelined_array-0.0.13/pyproject.toml

@@ -1,45 +0,0 @@
-[project]
-name = "timelined_array"
-description = "Manage easily 1 or multidimensionnal samples numpy arrays that are time related. Extends numpy without removing any of it's abilities on such arrays."
-authors = [
-    { name = "Timothe Jost", email = "timothe.jost@wanadoo.fr" },
-]
-dependencies = [
-    "numpy",
-]
-requires-python = ">=3.11"
-readme = "README.md"
-dynamic = []
-version = "0.0.13"
-
-[project.license]
-text = "MIT"
-
-[project.urls]
-Homepage = "https://pypi.org/project/timelined_array/"
-Source = "https://github.com/JostTim/timelined_array"
-
-[build-system]
-requires = [
-    "pdm-backend",
-]
-build-backend = "pdm.backend"
-
-[tool.pdm]
-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",
-]