Remove RunningState and change method running to started property

Signed-off-by: Mathias L. Baumann <[email protected]>

Author: Marenz

RELEASE_NOTES.md

@@ -3,7 +3,7 @@
 ## New Features
 
 * Update BaseApiClient to get the http2 keepalive feature.
-* Some Methods from the high-level API have been moved to this repo: The dispatch class now offers: `until`, `running`, `next_run` and `next_run_after`.
+* Some Methods from the high-level API have been moved to this repo: The dispatch class now offers: `until`, `started`, `next_run` and `next_run_after`.
 
 ## Bug Fixes
 

src/frequenz/client/dispatch/types.py

@@ -6,7 +6,7 @@
 
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
-from enum import Enum, IntEnum
+from enum import IntEnum
 from typing import Any, cast
 
 # pylint: disable=no-name-in-module
@@ -115,19 +115,6 @@ class TimeIntervalFilter:
     """Filter by end_time < end_to."""
 
 
-class RunningState(Enum):
-    """The running state of a dispatch."""
-
-    RUNNING = "RUNNING"
-    """The dispatch is running."""
-
-    STOPPED = "STOPPED"
-    """The dispatch is stopped."""
-
-    DIFFERENT_TYPE = "DIFFERENT_TYPE"
-    """The dispatch is for a different type."""
-
-
 @dataclass(kw_only=True, frozen=True)
 class Dispatch:  # pylint: disable=too-many-instance-attributes
     """Represents a dispatch operation within a microgrid system."""
@@ -173,36 +160,33 @@ class Dispatch:  # pylint: disable=too-many-instance-attributes
     update_time: datetime
     """The last update time of the dispatch in UTC. Set when a dispatch is modified."""
 
-    def running(self, type_: str) -> RunningState:
-        """Check if the dispatch is currently supposed to be running.
+    @property
+    def started(self) -> bool:
+        """Check if the dispatch has started.
 
-        Args:
-            type_: The type of the dispatch that should be running.
+        A dispatch is considered started if the current time is after the start
+        time but before the end time.
 
-        Returns:
-            RUNNING if the dispatch is running,
-            STOPPED if it is stopped,
-            DIFFERENT_TYPE if it is for a different type.
+        Recurring dispatches are considered started if the current time is after
+        the start time of the last occurrence but before the end time of the
+        last occurrence.
         """
-        if self.type != type_:
-            return RunningState.DIFFERENT_TYPE
-
         if not self.active:
-            return RunningState.STOPPED
+            return False
 
         now = datetime.now(tz=timezone.utc)
 
         if now < self.start_time:
-            return RunningState.STOPPED
+            return False
 
         # A dispatch without duration is always running, once it started
         if self.duration is None:
-            return RunningState.RUNNING
+            return True
 
         if until := self._until(now):
-            return RunningState.RUNNING if now < until else RunningState.STOPPED
+            return now < until
 
-        return RunningState.STOPPED
+        return False
 
     @property
     def until(self) -> datetime | None:

tests/test_dispatch.py

@@ -11,7 +11,7 @@
 
 from frequenz.client.common.microgrid.components import ComponentCategory
 from frequenz.client.dispatch.recurrence import Frequency, RecurrenceRule, Weekday
-from frequenz.client.dispatch.types import Dispatch, RunningState
+from frequenz.client.dispatch.types import Dispatch
 
 # Define a fixed current time for testing to avoid issues with datetime.now()
 CURRENT_TIME = datetime(2023, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
@@ -37,84 +37,62 @@ def dispatch_base() -> Dispatch:
 
 @time_machine.travel(CURRENT_TIME)
 @pytest.mark.parametrize(
-    "dispatch_type, requested_type, active, start_time_offset, duration, expected_state",
+    "active, start_time_offset, duration, expected_state",
     [
-        # Dispatch type does not match the requested type
-        (
-            "TypeA",
-            "TypeB",
-            True,
-            timedelta(minutes=-10),
-            timedelta(minutes=20),
-            RunningState.DIFFERENT_TYPE,
-        ),
         # Dispatch is inactive
         (
-            "TypeA1",
-            "TypeA1",
             False,
             timedelta(minutes=-10),
             timedelta(minutes=20),
-            RunningState.STOPPED,
+            False,
         ),
         # Current time is before the start time
         (
-            "TypeA2",
-            "TypeA2",
             True,
             timedelta(minutes=10),
             timedelta(minutes=20),
-            RunningState.STOPPED,
+            False,
         ),
         # Dispatch with infinite duration
         (
-            "TypeA3",
-            "TypeA3",
             True,
             timedelta(minutes=-10),
             None,
-            RunningState.RUNNING,
+            True,
         ),
         # Dispatch is currently running
         (
-            "TypeA4",
-            "TypeA4",
             True,
             timedelta(minutes=-10),
             timedelta(minutes=20),
-            RunningState.RUNNING,
+            True,
         ),
         # Dispatch duration has passed
         (
-            "TypeA5",
-            "TypeA5",
             True,
             timedelta(minutes=-30),
             timedelta(minutes=20),
-            RunningState.STOPPED,
+            False,
         ),
     ],
 )
 # pylint: disable=too-many-arguments,too-many-positional-arguments
 def test_dispatch_running(
     dispatch_base: Dispatch,
-    dispatch_type: str,
-    requested_type: str,
     active: bool,
     start_time_offset: timedelta,
     duration: timedelta | None,
-    expected_state: RunningState,
+    expected_state: bool,
 ) -> None:
     """Test the running method of the Dispatch class."""
     dispatch = replace(
         dispatch_base,
-        type=dispatch_type,
         start_time=CURRENT_TIME + start_time_offset,
         duration=duration,
         active=active,
     )
 
-    assert dispatch.running(requested_type) == expected_state
+    assert dispatch.started == expected_state
 
 
 @time_machine.travel(CURRENT_TIME)