timelined_array 0.0.8__tar.gz → 0.0.10__tar.gz

{timelined_array-0.0.8 → timelined_array-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: timelined_array
-Version: 0.0.8
+Version: 0.0.10
 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

{timelined_array-0.0.8 → timelined_array-0.0.10}/pyproject.toml

@@ -10,7 +10,7 @@ dependencies = [
 requires-python = ">=3.11"
 readme = "README.md"
 dynamic = []
-version = "0.0.8"
+version = "0.0.10"
 
 [project.license]
 text = "MIT"

timelined_array-0.0.10/src/timelined_array/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "0.0.10"
+
+from .time import TimelinedArray, MaskedTimelinedArray

{timelined_array-0.0.8 → timelined_array-0.0.10}/src/timelined_array/time.py

@@ -2,10 +2,13 @@
 
 import numpy as np
 from logging import getLogger
-from typing import Tuple, List, Protocol, Type
 from enum import Enum
 import operator
 
+from typing import Tuple, List, Protocol, Type, Callable, Any
+
+OperatorType = Callable[[Any, Any], bool]
+
 # class syntax
 
 logger = getLogger("timelined_array")
@@ -149,56 +152,39 @@ class Timeline(np.ndarray):
         return self._max_step * self.max_step_mult
 
 
-class Boundary(Enum):
-    inclusive = 0
-    exclusive = 1
-    inc = 0
-    exc = 1
+class StartBoundary(Enum):
+    inclusive = operator.ge
+    exclusive = operator.gt
+    inc = operator.ge
+    exc = operator.gt
 
-    @staticmethod
-    def get_operation(boundary, setting):
-        """Return the appropriate comparison operator based on the boundary and setting.
 
-        Args:
-            boundary (str): The boundary type, either "start" or "stop".
-            setting (Boundary): The setting for the boundary, either inclusive or exclusive.
+class StoptBoundary(Enum):
+    inclusive = operator.le
+    exclusive = operator.lt
+    inc = operator.le
+    exc = operator.lt
 
-        Returns:
-            function: The comparison operator based on the boundary and setting.
 
-        Raises:
-            ValueError: If the boundary or setting is invalid.
-        """
-
-        if boundary == "start":
-            if setting == Boundary.inclusive:
-                return operator.ge
-            elif setting == Boundary.exclusive:
-                return operator.gt
-            else:
-                raise ValueError
-        elif boundary == "stop":
-            if setting == Boundary.inclusive:
-                return operator.le
-            elif setting == Boundary.exclusive:
-                return operator.lt
-            else:
-                raise ValueError
-        else:
-            raise ValueError
+class EdgePolicy(Enum):
+    start = StartBoundary
+    stop = StoptBoundary
 
 
 class TimeIndexer:
     """The time indexer indexes by default from >= to the time start, and strictly < to time stop"""
 
-    start_mode = Boundary.inclusive
-    stop_mode = Boundary.exclusive
-
-    _start_operation = Boundary.get_operation("start", start_mode)
-    _stop_operation = Boundary.get_operation("stop", stop_mode)
+    _start_operation: OperatorType
+    _stop_operation: OperatorType
 
-    def __init__(self, array: TimeCompatibleProtocol):
+    def __init__(self, array: TimeCompatibleProtocol, start="inclusive", stop="exclusive"):
         self.array = array
+        self.set_edge_policy(start, stop)
+
+    def set_edge_policy(self, start="inclusive", stop="exclusive"):
+        self._start_operation = EdgePolicy["start"].value[start].value
+        self._stop_operation = EdgePolicy["stop"].value[stop].value
+        return self
 
     def time_to_index(
         self, time: float | int | slice | Tuple[int | float] | List[float | int | slice | Tuple[int | float]]
@@ -229,7 +215,7 @@ class TimeIndexer:
         elif isinstance(time, (int, float)):
             return self.get_iindex(sec_start=time).start
         else:
-            raise ValueError("Cannot process time to index ")
+            raise ValueError("Cannot process time to index")
 
     seconds_to_index = time_to_index
 
@@ -333,17 +319,16 @@ class TimeIndexer:
                 step = 1
         return slice(start, stop, step)
 
-    def __call__(self, start=None, stop=None):
-        if start is not None:
-            self._start_operation = Boundary.get_operation("start", start)
-        if stop is not None:
-            self._stop_operation = Boundary.get_operation("stop", stop)
+    def __call__(self, start="inclusive", stop="exclusive"):
+        return self.set_edge_policy(start, stop)
 
 
 class TimeMixin:
 
     time_dimension: int
     timeline: Timeline
+    start_policy = "inclusive"
+    stop_policy = "exclusive"
 
     def _time_dimension_in_axis(self, axis: int | Tuple[int, ...] | None) -> bool:
         """Check if the time dimension is present in the specified axis.
@@ -622,7 +607,7 @@ class TimeMixin:
     def itime(self: TimeCompatibleProtocol):
         """Return a TimeIndexer object based on the given TimeCompatibleProtocol object."""
 
-        return TimeIndexer(self)
+        return TimeIndexer(self, self.start_policy, self.stop_policy)
 
     isec = itime
 
@@ -1184,7 +1169,7 @@ class TimelinedArray(TimeMixin, np.ndarray, TimeCompatibleProtocol):
         index, final_timeline, final_time_dimension = self._get_indexed_times(index)
 
         if final_timeline is None or final_time_dimension is None:
-            return np.array(self).__getitem__(index)
+            return np.asarray(self).__getitem__(index)
 
         indexed_result = super().__getitem__(index)
 

timelined_array-0.0.8/src/timelined_array/__init__.py

@@ -1,3 +0,0 @@
-__version__ = "0.0.8"
-
-from .time import TimelinedArray, MaskedTimelinedArray, Seconds, Boundary