Remove methods that were moved to client repo

* The `running` property was renamed to `started`
* The running state was removed

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

Author: Marenz

README.md

@@ -21,7 +21,7 @@ The [`Dispatcher` class](https://frequenz-floss.github.io/frequenz-dispatch-pyth
 
 ```python
 import os
-from frequenz.dispatch import Dispatcher, RunningState
+from frequenz.dispatch import Dispatcher
 from unittest.mock import MagicMock
 
 async def run():
@@ -42,29 +42,29 @@ async def run():
     changed_running_status_rx = dispatcher.running_status_change.new_receiver()
 
     async for dispatch in changed_running_status_rx:
-        match dispatch.running("DEMO_TYPE"):
-            case RunningState.RUNNING:
-                print(f"Executing dispatch {dispatch.id}, due on {dispatch.start_time}")
-                if actor.is_running:
-                    actor.reconfigure(
-                        components=dispatch.target,
-                        run_parameters=dispatch.payload, # custom actor parameters
-                        dry_run=dispatch.dry_run,
-                        until=dispatch.until,
-                    )  # this will reconfigure the actor
-                else:
-                    # this will start a new actor with the given components
-                    # and run it for the duration of the dispatch
-                    actor.start(
-                        components=dispatch.target,
-                        run_parameters=dispatch.payload, # custom actor parameters
-                        dry_run=dispatch.dry_run,
-                        until=dispatch.until,
-                    )
-            case RunningState.STOPPED:
-                actor.stop()  # this will stop the actor
-            case RunningState.DIFFERENT_TYPE:
-                pass  # dispatch not for this type
+        if dispatch.type != "MY_TYPE":
+            continue
+
+        if dispatch.started:
+            print(f"Executing dispatch {dispatch.id}, due on {dispatch.start_time}")
+            if actor.is_running:
+                actor.reconfigure(
+                    components=dispatch.target,
+                    run_parameters=dispatch.payload, # custom actor parameters
+                    dry_run=dispatch.dry_run,
+                    until=dispatch.until,
+                )  # this will reconfigure the actor
+            else:
+                # this will start a new actor with the given components
+                # and run it for the duration of the dispatch
+                actor.start(
+                    components=dispatch.target,
+                    run_parameters=dispatch.payload, # custom actor parameters
+                    dry_run=dispatch.dry_run,
+                    until=dispatch.until,
+                )
+        else:
+            actor.stop()  # this will stop the actor
 ```
 
 ## Supported Platforms

RELEASE_NOTES.md

@@ -6,7 +6,7 @@
 
 ## Upgrading
 
-<!-- Here goes notes on how to upgrade from previous versions, including deprecations and what they should be replaced with -->
+* The method `Dispatch.running(type: str)` was replaced with the property `Dispatch.started: bool`.
 
 ## New Features
 

src/frequenz/dispatch/__init__.py

@@ -15,7 +15,7 @@
 
 """
 
-from ._dispatch import Dispatch, RunningState
+from ._dispatch import Dispatch
 from ._dispatcher import Dispatcher, ReceiverFetcher
 from ._event import Created, Deleted, DispatchEvent, Updated
 from ._managing_actor import DispatchManagingActor, DispatchUpdate
@@ -28,7 +28,6 @@
     "ReceiverFetcher",
     "Updated",
     "Dispatch",
-    "RunningState",
     "DispatchManagingActor",
     "DispatchUpdate",
 ]

src/frequenz/dispatch/_dispatch.py

@@ -3,53 +3,12 @@
 
 """Dispatch type with support for next_run calculation."""
 
-
-import logging
 from dataclasses import dataclass
 from datetime import datetime, timezone
-from enum import Enum
-from typing import Iterator, cast
+from typing import Iterator
 
-from dateutil import rrule
-from frequenz.client.dispatch.recurrence import Frequency, Weekday
 from frequenz.client.dispatch.types import Dispatch as BaseDispatch
 
-_logger = logging.getLogger(__name__)
-"""The logger for this module."""
-
-_RRULE_FREQ_MAP = {
-    Frequency.MINUTELY: rrule.MINUTELY,
-    Frequency.HOURLY: rrule.HOURLY,
-    Frequency.DAILY: rrule.DAILY,
-    Frequency.WEEKLY: rrule.WEEKLY,
-    Frequency.MONTHLY: rrule.MONTHLY,
-}
-"""To map from our Frequency enum to the dateutil library enum."""
-
-_RRULE_WEEKDAY_MAP = {
-    Weekday.MONDAY: rrule.MO,
-    Weekday.TUESDAY: rrule.TU,
-    Weekday.WEDNESDAY: rrule.WE,
-    Weekday.THURSDAY: rrule.TH,
-    Weekday.FRIDAY: rrule.FR,
-    Weekday.SATURDAY: rrule.SA,
-    Weekday.SUNDAY: rrule.SU,
-}
-"""To map from our Weekday enum to the dateutil library enum."""
-
-
-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(frozen=True)
 class Dispatch(BaseDispatch):
@@ -87,6 +46,18 @@ def _set_deleted(self) -> None:
         """Mark the dispatch as deleted."""
         object.__setattr__(self, "deleted", True)
 
+    @property
+    def started(self) -> bool:
+        """Check if the dispatch is started.
+
+        Returns:
+            True if the dispatch is started, False otherwise.
+        """
+        if self.deleted:
+            return False
+
+        return super().started
+
     @property
     def _running_status_notified(self) -> bool:
         """Check that the latest running state change notification was sent.
@@ -100,52 +71,6 @@ def _set_running_status_notified(self) -> None:
         """Mark the latest running state change notification as sent."""
         object.__setattr__(self, "running_state_change_synced", self.update_time)
 
-    def running(self, type_: str) -> RunningState:
-        """Check if the dispatch is currently supposed to be running.
-
-        Args:
-            type_: The type of the dispatch that should be running.
-
-        Returns:
-            RUNNING if the dispatch is running,
-            STOPPED if it is stopped,
-            DIFFERENT_TYPE if it is for a different type.
-        """
-        if self.type != type_:
-            return RunningState.DIFFERENT_TYPE
-
-        if not self.active or self.deleted:
-            return RunningState.STOPPED
-
-        now = datetime.now(tz=timezone.utc)
-
-        if now < self.start_time:
-            return RunningState.STOPPED
-        # A dispatch without duration is always running once it started
-        if self.duration is None:
-            return RunningState.RUNNING
-
-        if until := self._until(now):
-            return RunningState.RUNNING if now < until else RunningState.STOPPED
-
-        return RunningState.STOPPED
-
-    @property
-    def until(self) -> datetime | None:
-        """Time when the dispatch should end.
-
-        Returns the time that a running dispatch should end.
-        If the dispatch is not running, None is returned.
-
-        Returns:
-            The time when the dispatch should end or None if the dispatch is not running.
-        """
-        if not self.active or self.deleted:
-            return None
-
-        now = datetime.now(tz=timezone.utc)
-        return self._until(now)
-
     @property
     # noqa is needed because of a bug in pydoclint that makes it think a `return` without a return
     # value needs documenting
@@ -170,103 +95,3 @@ def missed_runs(self) -> Iterator[datetime]:  # noqa: DOC405
         while (next_run := self.next_run_after(from_time)) and next_run < now:
             yield next_run
             from_time = next_run
-
-    @property
-    def next_run(self) -> datetime | None:
-        """Calculate the next run of a dispatch.
-
-        Returns:
-            The next run of the dispatch or None if the dispatch is finished.
-        """
-        return self.next_run_after(datetime.now(tz=timezone.utc))
-
-    def next_run_after(self, after: datetime) -> datetime | None:
-        """Calculate the next run of a dispatch.
-
-        Args:
-            after: The time to calculate the next run from.
-
-        Returns:
-            The next run of the dispatch or None if the dispatch is finished.
-        """
-        if (
-            not self.recurrence.frequency
-            or self.recurrence.frequency == Frequency.UNSPECIFIED
-            or self.duration is None  # Infinite duration
-        ):
-            if after > self.start_time:
-                return None
-            return self.start_time
-
-        # Make sure no weekday is UNSPECIFIED
-        if Weekday.UNSPECIFIED in self.recurrence.byweekdays:
-            _logger.warning("Dispatch %s has UNSPECIFIED weekday, ignoring...", self.id)
-            return None
-
-        # No type information for rrule, so we need to cast
-        return cast(datetime | None, self._prepare_rrule().after(after, inc=True))
-
-    def _prepare_rrule(self) -> rrule.rrule:
-        """Prepare the rrule object.
-
-        Returns:
-            The rrule object.
-
-        Raises:
-            ValueError: If the interval is invalid.
-        """
-        count, until = (None, None)
-        if end := self.recurrence.end_criteria:
-            count = end.count
-            until = end.until
-
-        if self.recurrence.interval is None or self.recurrence.interval < 1:
-            raise ValueError("Interval must be at least 1")
-
-        rrule_obj = rrule.rrule(
-            freq=_RRULE_FREQ_MAP[self.recurrence.frequency],
-            dtstart=self.start_time,
-            count=count,
-            until=until,
-            byminute=self.recurrence.byminutes or None,
-            byhour=self.recurrence.byhours or None,
-            byweekday=[
-                _RRULE_WEEKDAY_MAP[weekday] for weekday in self.recurrence.byweekdays
-            ]
-            or None,
-            bymonthday=self.recurrence.bymonthdays or None,
-            bymonth=self.recurrence.bymonths or None,
-            interval=self.recurrence.interval,
-        )
-
-        return rrule_obj
-
-    def _until(self, now: datetime) -> datetime | None:
-        """Calculate the time when the dispatch should end.
-
-        If no previous run is found, None is returned.
-
-        Args:
-            now: The current time.
-
-        Returns:
-            The time when the dispatch should end or None if the dispatch is not running.
-
-        Raises:
-            ValueError: If the dispatch has no duration.
-        """
-        if self.duration is None:
-            raise ValueError("_until: Dispatch has no duration")
-
-        if (
-            not self.recurrence.frequency
-            or self.recurrence.frequency == Frequency.UNSPECIFIED
-        ):
-            return self.start_time + self.duration
-
-        latest_past_start: datetime | None = self._prepare_rrule().before(now, inc=True)
-
-        if not latest_past_start:
-            return None
-
-        return latest_past_start + self.duration

src/frequenz/dispatch/_dispatcher.py

@@ -54,7 +54,7 @@ class Dispatcher:
     Example: Processing running state change dispatches
         ```python
         import os
-        from frequenz.dispatch import Dispatcher, RunningState
+        from frequenz.dispatch import Dispatcher
         from unittest.mock import MagicMock
 
         async def run():
@@ -75,29 +75,29 @@ async def run():
             changed_running_status = dispatcher.running_status_change.new_receiver()
 
             async for dispatch in changed_running_status:
-                match dispatch.running("DEMO_TYPE"):
-                    case RunningState.RUNNING:
-                        print(f"Executing dispatch {dispatch.id}, due on {dispatch.start_time}")
-                        if actor.is_running:
-                            actor.reconfigure(
-                                components=dispatch.target,
-                                run_parameters=dispatch.payload, # custom actor parameters
-                                dry_run=dispatch.dry_run,
-                                until=dispatch.until,
-                            )  # this will reconfigure the actor
-                        else:
-                            # this will start a new actor with the given components
-                            # and run it for the duration of the dispatch
-                            actor.start(
-                                components=dispatch.target,
-                                run_parameters=dispatch.payload, # custom actor parameters
-                                dry_run=dispatch.dry_run,
-                                until=dispatch.until,
-                            )
-                    case RunningState.STOPPED:
-                        actor.stop()  # this will stop the actor
-                    case RunningState.DIFFERENT_TYPE:
-                        pass  # dispatch not for this type
+                if dispatch.type != "YOUR_DISPATCH_TYPE":
+                    continue
+
+                if dispatch.started:
+                    print(f"Executing dispatch {dispatch.id}, due on {dispatch.start_time}")
+                    if actor.is_running:
+                        actor.reconfigure(
+                            components=dispatch.target,
+                            run_parameters=dispatch.payload, # custom actor parameters
+                            dry_run=dispatch.dry_run,
+                            until=dispatch.until,
+                        )  # this will reconfigure the actor
+                    else:
+                        # this will start a new actor with the given components
+                        # and run it for the duration of the dispatch
+                        actor.start(
+                            components=dispatch.target,
+                            run_parameters=dispatch.payload, # custom actor parameters
+                            dry_run=dispatch.dry_run,
+                            until=dispatch.until,
+                        )
+                else:
+                    actor.stop()  # this will stop the actor
         ```
 
     Example: Getting notification about dispatch lifecycle events