Add TimeDeltaArray to bintime

src/nitypes/bintime/__init__.py

@@ -74,6 +74,7 @@
 )
 from nitypes.bintime._time_value_tuple import TimeValueTuple
 from nitypes.bintime._timedelta import TimeDelta
+from nitypes.bintime._timedelta_array import TimeDeltaArray
 
 __all__ = [
     "DateTime",
@@ -82,6 +83,7 @@
     "CVITimeIntervalBase",
     "CVITimeIntervalDType",
     "TimeDelta",
+    "TimeDeltaArray",
     "TimeValueTuple",
 ]
 

src/nitypes/bintime/_timedelta_array.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import (
+    Union,
+    final,
+    overload,
+)
+
+import numpy as np
+
+from nitypes.bintime import CVITimeIntervalDType, TimeDelta, TimeValueTuple
+
+
+@final
+class TimeDeltaArray(Sequence[TimeDelta]):
+    """An array of TimeDelta values in NI Binary Time Format (NI-BTF)."""
+
+    __slots__ = ["_array"]
+
+    _array: np.ndarray
+
+    def __init__(
+        self,
+        value: Union[Sequence[TimeDelta], None] = None,
+    ) -> None:
+        """Initialize a new TimeDeltaArray."""
+        if value is None:
+            value = []
+        self._array = np.zeros(len(value), dtype=CVITimeIntervalDType)
+        for index, entry in enumerate(value):
+            self._array[index] = entry.to_tuple()
+
+    @overload
+    def __getitem__(  # noqa: D105 - missing docstring in magic method
+        self, index: int
+    ) -> TimeDelta: ...
+
+    @overload
+    def __getitem__(  # noqa: D105 - missing docstring in magic method
+        self, index: slice
+    ) -> Sequence[TimeDelta]: ...
+
+    def __getitem__(self, index: Union[int, slice]) -> Union[TimeDelta, Sequence[TimeDelta]]:
+        """Return the TimeDelta at the specified location."""
+        if isinstance(index, int):
+            entry = self._array[index]
+            # Without casting via int(), local variable as_tuple holds
+            #   TimeValueTuple(whole_seconds=np.uint64(1), fractional_seconds=np.int64(0))
+            # and TimeDelta.from_tuple() raises
+            #   TypeError: ufunc 'bitwise_or' not supported for the input types, and the inputs
+            #   could not be safely coerced to any supported types according to the casting rule
+            #   ''safe''
+            as_tuple = TimeValueTuple(int(entry[0]), int(entry[1]))
+            return TimeDelta.from_tuple(as_tuple)
+        elif isinstance(index, slice):
+            raise NotImplementedError("TODO AB#3137071")
+        else:
+            raise TypeError("Index must be an int or slice")
+
+    def __len__(self) -> int:
+        """Return the length of the array."""
+        return np.size(self._array)

tests/unit/bintime/test_timedelta_array.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing_extensions import assert_type
+
+from nitypes.bintime import TimeDelta
+from nitypes.bintime import TimeDeltaArray
+
+
+def test___no_args___construct___returns_empty_array() -> None:
+    value = TimeDeltaArray()
+
+    assert_type(value, TimeDeltaArray)
+    assert isinstance(value, TimeDeltaArray)
+    assert len(value._array) == 0
+
+
+def test___list_arg___construct___returns_matching_array() -> None:
+    arg = [TimeDelta(1), TimeDelta(20), TimeDelta(500)]
+    value = TimeDeltaArray(arg)
+
+    assert_type(value, TimeDeltaArray)
+    assert isinstance(value, TimeDeltaArray)
+    assert len(value._array) == len(arg)
+    assert tuple(value._array[0]) == TimeDelta(1).to_tuple()
+    assert tuple(value._array[1]) == TimeDelta(20).to_tuple()
+    assert tuple(value._array[2]) == TimeDelta(500).to_tuple()