Add TimeDeltaArray to bintime

src/nitypes/bintime/_timedelta_array.py

@@ -11,6 +11,8 @@
 import numpy as np
 import numpy.typing as npt
 
+from nitypes._exceptions import invalid_arg_value, invalid_arg_type
+
 if TYPE_CHECKING:
     # Import from the public package so the docs don't reference private submodules.
     from nitypes.bintime import CVITimeIntervalDType, TimeDelta, TimeValueTuple
@@ -40,7 +42,7 @@ def __init__(
         if value is None:
             value = []
         if not all(isinstance(item, TimeDelta) for item in value):
-            raise TypeError("Cannot assign values that are not of type TimeDelta")
+            raise invalid_arg_type("value", "iterable of TimeDelta", value)
         self._array = np.fromiter(
             (entry.to_tuple().to_cvi() for entry in value),
             dtype=CVITimeIntervalDType,
@@ -64,8 +66,6 @@ def __getitem__(self, index: int | slice) -> TimeDelta | TimeDeltaArray:
             TypeError: If index is an invalid type.
             IndexError: If index is out of range.
         """
-        if isinstance(index, bool):
-            raise TypeError("Cannot index with bool")
         if isinstance(index, int):
             entry = self._array[index].item()
             as_tuple = TimeValueTuple.from_cvi(*entry)
@@ -76,7 +76,7 @@ def __getitem__(self, index: int | slice) -> TimeDelta | TimeDeltaArray:
             new_array._array = sliced_entries
             return new_array
         else:
-            raise TypeError("Index must be an int or slice")
+            raise invalid_arg_type("index", "int or slice", index)
 
     def __len__(self) -> int:
         """Return len(self)."""
@@ -100,26 +100,40 @@ def __setitem__(self, index: int | slice, value: TimeDelta | Iterable[TimeDelta]
             ValueError: If slice assignment length doesn't match the selected range.
             IndexError: If index is out of range.
         """
-        if isinstance(index, bool):
-            raise TypeError("Cannot index with bool")
         if isinstance(index, int):
             if not isinstance(value, TimeDelta):
-                raise TypeError("Cannot assign value that is not of type TimeDelta")
+                raise invalid_arg_type("value", "TimeDelta", value)
             self._array[index] = value.to_tuple().to_cvi()
         elif isinstance(index, slice):
+            selection = index.indices(len(self))
+            selected_count = len(range(*selection))
+            if selected_count == 0:
+                return
+
             if not isinstance(value, Iterable):
-                raise TypeError("Cannot assign a slice with a non-iterable")
+                raise invalid_arg_type("value", "iterable of TimeDelta", value)
             if not all(isinstance(item, TimeDelta) for item in value):
-                raise TypeError("Cannot assign values that are not of type TimeDelta")
-            selected_count = len(range(*index.indices(len(self))))
+                raise invalid_arg_type("value", "iterable of TimeDelta", value)
+
             values = list(value)
             new_entry_count = len(values)
-            if new_entry_count != selected_count:
-                message = f"Cannot assign slice with unmatched length. Expected {selected_count} but received {new_entry_count}"
-                raise ValueError(message)
+            step_size = selection[-1]
+            if step_size > 1:
+                if new_entry_count <= 1:
+                    raise invalid_arg_value("index", "slice with step size 1", index)
+                elif new_entry_count != selected_count:
+                    raise invalid_arg_value(
+                        "value", "iterable with the same length as the slice", value
+                    )
+
+            if new_entry_count == 0:
+                return self.__delitem__(index)
+            if new_entry_count == 1:
+                self.__delitem__(index)
+                return self.insert(selection[0], values[0])
             self._array[index] = [item.to_tuple().to_cvi() for item in values]
         else:
-            raise TypeError("Index must be an int or slice")
+            raise invalid_arg_type("index", "int or slice", index)
 
     @overload
     def __delitem__(self, index: int) -> None: ...  # noqa: D105 - missing docstring in magic method
@@ -136,48 +150,28 @@ def __delitem__(self, index: int | slice) -> None:
             TypeError: If index is an invalid type.
             IndexError: If index is out of range.
         """
-        if isinstance(index, bool):
-            raise TypeError("Cannot index with bool")
         if isinstance(index, (int, slice)):
             self._array = np.delete(self._array, index)
         else:
-            raise TypeError("Index must be an int or slice")
+            raise invalid_arg_type("index", "int or slice", index)
 
     def insert(self, index: int, value: TimeDelta) -> None:
         """Insert the TimeDelta value before the specified index.
 
         Raises:
             TypeError: If index is not int or value is not TimeDelta.
         """
-        if isinstance(index, bool):
-            raise TypeError("Cannot insert with bool")
         if not isinstance(index, int):
-            raise TypeError("Index must be an int")
+            raise invalid_arg_type("index", "int", index)
         if not isinstance(value, TimeDelta):
-            raise TypeError("Cannot assign value that is not of type TimeDelta")
+            raise invalid_arg_type("value", "TimeDelta", value)
         lower = -len(self._array)
         upper = len(self._array)
         index = min(max(index, lower), upper)
         as_cvi = value.to_tuple().to_cvi()
         self._array = np.insert(self._array, index, as_cvi)
 
-    def __imul__(self, multiplier: int) -> TimeDeltaArray:
-        """Return self*=multiplier.
-
-        Raises:
-            TypeError: If multiplier is not an integer.
-        """
-        if isinstance(multiplier, bool):
-            raise TypeError("Cannot multiply with bool")
-        if not isinstance(multiplier, int):
-            raise TypeError("Multiplier must be an int")
-        if multiplier <= 0:
-            self._array = np.array([], dtype=CVITimeIntervalDType)
-        else:
-            self._array = np.tile(self._array, multiplier)
-        return self
-
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         """Return self == other."""
         if not isinstance(other, TimeDeltaArray):
             return NotImplemented

tests/unit/bintime/test_datetime.py

@@ -14,9 +14,9 @@
 from nitypes.bintime._timedelta import _BITS_PER_SECOND, _FRACTIONAL_SECONDS_MASK
 
 
-#############
+###############################################################################
 # Constructor
-#############
+###############################################################################
 def test___no_args___construct___returns_epoch() -> None:
     value = DateTime()
 
@@ -124,9 +124,9 @@ def test___local_unit_args___construct___raises_value_error() -> None:
     assert exc.value.args[0].startswith("The tzinfo must be datetime.timezone.utc.")
 
 
-############
+###############################################################################
 # from_ticks
-############
+###############################################################################
 def test___int_ticks___from_ticks___returns_time_value() -> None:
     value = DateTime.from_ticks(0x12345678_90ABCDEF_FEDCBA09_87654321)
 
@@ -135,9 +135,9 @@ def test___int_ticks___from_ticks___returns_time_value() -> None:
     assert value._offset._ticks == 0x12345678_90ABCDEF_FEDCBA09_87654321
 
 
-#############
+###############################################################################
 # from_offset
-#############
+###############################################################################
 def test___time_value___from_offset___returns_time_value() -> None:
     value = DateTime.from_offset(TimeDelta.from_ticks(0x12345678_90ABCDEF_FEDCBA09_87654321))
 
@@ -146,9 +146,9 @@ def test___time_value___from_offset___returns_time_value() -> None:
     assert value._offset._ticks == 0x12345678_90ABCDEF_FEDCBA09_87654321
 
 
-##############################################
+###############################################################################
 # year, month, day, hour, minute, second, etc.
-##############################################
+###############################################################################
 @pytest.mark.parametrize(
     "other, expected",
     [
@@ -210,9 +210,9 @@ def test___various_values___unit_properties___return_unit_values(
     ) == expected
 
 
-###################
+###############################################################################
 # Binary arithmetic
-###################
+###############################################################################
 @pytest.mark.parametrize(
     "left, right, expected",
     [
@@ -304,9 +304,9 @@ def test___datetime___sub___returns_time_value(
     assert left - right == expected
 
 
-############
+###############################################################################
 # Comparison
-############
+###############################################################################
 @pytest.mark.parametrize(
     "left, right",
     [
@@ -395,9 +395,9 @@ def test___lesser_value___comparison___lesser(
     assert not (left >= right)
 
 
-###############
+###############################################################################
 # Miscellaneous
-###############
+###############################################################################
 _VARIOUS_VALUES = [
     DateTime(dt.MINYEAR, 1, 1, 0, 0, 0, 0, 0, 0, dt.timezone.utc),
     DateTime(1850, 12, 25, 8, 15, 30, 123_456, 234_567_789, 345_567_890, dt.timezone.utc),

tests/unit/bintime/test_timedelta.py

@@ -26,9 +26,9 @@
 _DT_EPSILON = ht.timedelta(microseconds=1)
 
 
-#############
+###############################################################################
 # Constructor
-#############
+###############################################################################
 def test___no_args___construct___returns_zero_timedelta() -> None:
     value = TimeDelta()
 
@@ -127,9 +127,9 @@ def test___invalid_seconds_type___construct___raises_type_error() -> None:
     assert exc.value.args[0].startswith("The seconds must be a number or timedelta.")
 
 
-############
+###############################################################################
 # from_ticks
-############
+###############################################################################
 def test___int_ticks___from_ticks___returns_timedelta() -> None:
     value = TimeDelta.from_ticks(0x12345678_90ABCDEF_FEDCBA09_87654321)
 
@@ -153,9 +153,9 @@ def test___unsupported_type___from_ticks___raises_type_error() -> None:
     assert exc.value.args[0].startswith("The ticks must be an integer.")
 
 
-#########################################################
+###############################################################################
 # days, seconds, microseconds, femtoseconds, yoctoseconds
-#########################################################
+###############################################################################
 @pytest.mark.parametrize(
     "value, expected",
     [
@@ -202,9 +202,9 @@ def test___various_values___unit_properties___return_unit_values(
     ) == expected
 
 
-###############
+###############################################################################
 # total_seconds
-###############
+###############################################################################
 @pytest.mark.parametrize(
     "seconds",
     [0.0, 1.0, 3.14159, -3.14159, 1.23456789e18, -1.23456789e18, 1.23456789e-18, -1.23456789e-18],
@@ -217,9 +217,9 @@ def test___float_seconds___total_seconds___approximate_match(seconds: float) ->
     assert total_seconds == pytest.approx(seconds)
 
 
-#########################
+###############################################################################
 # precision_total_seconds
-#########################
+###############################################################################
 @pytest.mark.parametrize(
     "seconds",
     [
@@ -311,9 +311,9 @@ def _random_state() -> Generator[tuple[Any, ...]]:
         random.setstate(state)
 
 
-##################
+###############################################################################
 # Unary arithmetic
-##################
+###############################################################################
 @pytest.mark.parametrize(
     "value, expected",
     [
@@ -370,9 +370,9 @@ def test___timedeltas___abs___returns_absolute_value(value: TimeDelta, expected:
     assert abs(value) == expected
 
 
-###################
+###############################################################################
 # Binary arithmetic
-###################
+###############################################################################
 @pytest.mark.parametrize(
     "left, right, expected",
     [
@@ -1054,9 +1054,9 @@ def test___ht_timedelta___divmod___returns_int_and_timedelta(
     assert divmod(left, right) == expected
 
 
-############
+###############################################################################
 # Comparison
-############
+###############################################################################
 @pytest.mark.parametrize(
     "left, right",
     [
@@ -1123,9 +1123,9 @@ def test___lesser_value___comparison___lesser(
     assert not (left >= right)
 
 
-###############
+###############################################################################
 # Miscellaneous
-###############
+###############################################################################
 @pytest.mark.parametrize(
     "value, expected",
     [