implement begin/end condition on event class

Author: mathieudpnt

src/osekit/core_api/base_data.py

@@ -103,6 +103,7 @@ def begin(self, value: Timestamp) -> None:
         Begin can only be set to a posterior date from the original begin.
 
         """
+        self.items = [item for item in self.items if item.end >= value]
         for item in self.items:
             item.begin = max(item.begin, value)
 
@@ -118,6 +119,7 @@ def end(self) -> Timestamp:
     @end.setter
     def end(self, value: Timestamp) -> None:
         """Return true if every item of this data object is empty."""
+        self.items = [item for item in self.items if item.begin < value]
         for item in self.items:
             item.end = min(item.end, value)
 

src/osekit/core_api/base_dataset.py

@@ -299,9 +299,6 @@ def from_files(  # noqa: PLR0913
             begin = min(file.begin for file in files)
         if not end:
             end = max(file.end for file in files)
-        if begin >= end:
-            msg = (f"`begin` ({begin}) must be smaller than `end`({end})")
-            raise ValueError(msg)
         if data_duration:
             data_base = (
                 cls._get_base_data_from_files_timedelta_total(

src/osekit/core_api/event.py

@@ -4,7 +4,7 @@
 
 import bisect
 import copy
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, TypeVar
 
 if TYPE_CHECKING:
@@ -15,15 +15,51 @@
 class Event:
     """Events are bounded between begin an end attributes.
 
-    Classes that have a begin and an end should inherit from Event.
+    Classes that have a beginning and an end should inherit from Event.
     """
 
-    begin: Timestamp
-    end: Timestamp
+    _begin: Timestamp = field(init=False, repr=False, compare=True)
+    _end: Timestamp = field(init=False, repr=False, compare=True)
+
+    def __init__(
+        self,
+        begin: Timestamp,
+        end: Timestamp
+    ) -> None:
+        """Initialize an Event instance with a beginning and an end."""
+        if begin > end:
+            msg = f"Invalid Event: `end` ({end}) must be greater than `begin` ({begin})."  # noqa: E501
+            raise ValueError(msg)
+        self._begin = begin
+        self._end = end
+
+    @property
+    def begin(self) -> Timestamp:
+        """Beginning of the event."""
+        return self._begin
+
+    @begin.setter
+    def begin(self, value: Timestamp) -> None:
+        if hasattr(self, "_end") and value > self._end:
+            msg = f"Invalid Event: `end` ({self._end}) must be greater than `begin` ({value})."  # noqa: E501
+            raise ValueError(msg)
+        self._begin = value
+
+    @property
+    def end(self) -> Timestamp:
+        """End of the event."""
+        return self._end
+
+    @end.setter
+    def end(self, value: Timestamp) -> None:
+        if hasattr(self, "_begin") and value < self._begin:
+            msg = f"Invalid Event: `end` ({value}) must be greater than `begin` ({self._begin})."  # noqa: E501
+            raise ValueError(msg)
+        self._end = value
 
     @property
     def duration(self) -> Timedelta:
-        """Return the total duration of the data in seconds."""
+        """Duration of the event."""
         return self.end - self.begin
 
     def overlaps(self, other: type[Event] | Event) -> bool:

tests/test_audio.py

@@ -1216,7 +1216,7 @@ def test_audio_dataset_from_files(
             [],
             pytest.raises(
                 ValueError,
-                match=r"`begin` .* must be smaller than `end`",
+                match=r"`end` .* must be greater than `begin`",
             ),
             pd.Timestamp("2024-01-01 12:01:00"),
             pd.Timestamp("2024-01-01 12:00:00"),

tests/test_event.py

@@ -326,3 +326,97 @@ def test_get_overlapping_events(
     )
 
     assert len(overlap_result) == len(expected_result)
+
+
+@pytest.mark.parametrize(
+    ("initial", "updates", "expected_values", "error_at"),
+    [
+        pytest.param(
+            [
+                ("begin", Timestamp("2024-01-01 00:00:00")),
+                ("end", Timestamp("2024-01-02 00:00:00")),
+            ],
+            [
+                ("begin", Timestamp("2024-01-01 12:00:00")),
+                ("end", Timestamp("2024-01-02 12:00:00")),
+            ],
+            (Timestamp("2024-01-01 12:00:00"), Timestamp("2024-01-02 12:00:00")),
+            None,
+            id="valid sequential updates",
+        ),
+        pytest.param(
+            [
+                ("begin", Timestamp("2024-01-01 00:00:00")),
+                ("end", Timestamp("2024-01-02 00:00:00")),
+            ],
+            [("begin", Timestamp("2024-01-03 00:00:00"))],
+            (Timestamp("2024-01-01 00:00:00"), Timestamp("2024-01-02 00:00:00")),
+            0,
+            id="invalid begin > end",
+        ),
+        pytest.param(
+            [
+                ("begin", Timestamp("2024-01-01 00:00:00")),
+                ("end", Timestamp("2024-01-02 00:00:00")),
+            ],
+            [("end", Timestamp("2023-12-31 23:59:59"))],
+            (Timestamp("2024-01-01 00:00:00"), Timestamp("2024-01-02 00:00:00")),
+            0,
+            id="invalid end < begin",
+        ),
+        pytest.param(
+            [
+                ("begin", Timestamp("2024-01-01 00:00:00")),
+                ("end", Timestamp("2024-01-02 00:00:00")),
+            ],
+            [
+                ("begin", Timestamp("2024-01-01 12:00:00")),
+                ("end", Timestamp("2024-01-01 06:00:00")),
+                ("end", Timestamp("2024-01-02 12:00:00")),
+            ],
+            (Timestamp("2024-01-01 12:00:00"), Timestamp("2024-01-02 12:00:00")),
+            1,
+            id="mixed valid and invalid updates",
+        ),
+        pytest.param(
+            [
+                ("begin", Timestamp("2024-01-01 00:00:00")),
+                ("end", Timestamp("2024-01-01 01:00:00")),
+            ],
+            [("begin", Timestamp("2024-01-01 01:00:00"))],
+            (Timestamp("2024-01-01 01:00:00"), Timestamp("2024-01-01 01:00:00")),
+            None,
+            id="begin equals end edge",
+        ),
+        pytest.param(
+            [
+                ("begin", Timestamp("2024-01-01 00:00:00")),
+                ("end", Timestamp("2024-01-01 01:00:00")),
+            ],
+            [("end", Timestamp("2024-01-01 00:00:00"))],
+            (Timestamp("2024-01-01 00:00:00"), Timestamp("2024-01-01 00:00:00")),
+            None,
+            id="end equals begin edge",
+        ),
+    ],
+)
+
+def test_event_begin_end_updates(
+    initial: list[tuple[str, Timestamp]],
+    updates: list[tuple[str, Timestamp]],
+    expected_values: tuple[Timestamp, Timestamp],
+    error_at: int | None,
+) -> None:
+    initial_dict = dict(initial)
+    cool_event = Event(begin=initial_dict["begin"], end=initial_dict["end"])
+
+    for i, (attr, value) in enumerate(updates):
+        if error_at is not None and i == error_at:
+            with pytest.raises(ValueError, match="`end`.*must be greater than `begin`.*"):
+                setattr(cool_event, attr, value)
+        else:
+            setattr(cool_event, attr, value)
+
+    assert cool_event.begin == expected_values[0]
+    assert cool_event.end == expected_values[1]
+