Represent durations as timedeltas rather than as floats

In the component status tracking parts of the power distributor.

Signed-off-by: Sahas Subramanian <[email protected]>

Author: shsms

src/frequenz/sdk/actor/power_distributing/_component_managers/_battery_manager.py

@@ -145,8 +145,8 @@ def __init__(
         self._component_pool_status_tracker = ComponentPoolStatusTracker(
             component_ids=set(self._battery_ids),
             component_status_sender=component_pool_status_sender,
-            max_blocking_duration_sec=30.0,
-            max_data_age_sec=10.0,
+            max_blocking_duration=timedelta(seconds=30.0),
+            max_data_age=timedelta(seconds=10.0),
             component_status_tracker_type=BatteryStatusTracker,
         )
 

src/frequenz/sdk/actor/power_distributing/_component_pool_status_tracker.py

@@ -7,6 +7,7 @@
 import asyncio
 import logging
 from collections import abc
+from datetime import timedelta
 
 from frequenz.channels import Broadcast, Receiver, Sender
 from frequenz.channels.util import Merge
@@ -34,8 +35,8 @@ def __init__(  # pylint: disable=too-many-arguments
         self,
         component_ids: abc.Set[int],
         component_status_sender: Sender[ComponentPoolStatus],
-        max_data_age_sec: float,
-        max_blocking_duration_sec: float,
+        max_data_age: timedelta,
+        max_blocking_duration: timedelta,
         component_status_tracker_type: type[ComponentStatusTracker],
     ) -> None:
         """Create ComponentPoolStatusTracker instance.
@@ -44,18 +45,17 @@ def __init__(  # pylint: disable=too-many-arguments
             component_ids: set of component ids whose status is to be tracked.
             component_status_sender: The sender used for sending the status of the
                 tracked components.
-            max_data_age_sec: If a component stops sending data, then this is the
-                maximum time for which its last message should be considered as
-                valid. After that time, the component won't be used until it starts
-                sending data.
-            max_blocking_duration_sec: This value tell what should be the maximum
-                timeout used for blocking failing component.
-            component_status_tracker_type: component status tracker to use
-                for tracking the status of the components.
+            max_data_age: If a component stops sending data, then this is the maximum
+                time for which its last message should be considered as valid. After
+                that time, the component won't be used until it starts sending data.
+            max_blocking_duration: This value tell what should be the maximum timeout
+                used for blocking failing component.
+            component_status_tracker_type: component status tracker to use for tracking
+                the status of the components.
         """
         self._component_ids = component_ids
-        self._max_data_age_sec = max_data_age_sec
-        self._max_blocking_duration_sec = max_blocking_duration_sec
+        self._max_data_age = max_data_age
+        self._max_blocking_duration = max_blocking_duration
         self._component_status_sender = component_status_sender
         self._component_status_tracker_type = component_status_tracker_type
 
@@ -99,8 +99,8 @@ def _make_merged_status_receiver(
             )
             tracker = self._component_status_tracker_type(
                 component_id=component_id,
-                max_data_age_sec=self._max_data_age_sec,
-                max_blocking_duration_sec=self._max_blocking_duration_sec,
+                max_data_age=self._max_data_age,
+                max_blocking_duration=self._max_blocking_duration,
                 status_sender=channel.new_sender(),
                 set_power_result_receiver=self._set_power_result_channel.new_receiver(),
             )

src/frequenz/sdk/actor/power_distributing/_component_status/_battery_status_tracker.py

@@ -55,55 +55,53 @@ class _ComponentStreamStatus:
 
 @dataclass
 class _BlockingStatus:
-    min_duration_sec: float
-    """The minimum blocking duration (in seconds)."""
+    min_duration: timedelta
+    """The minimum blocking duration."""
 
-    max_duration_sec: float
-    """The maximum blocking duration (in seconds)."""
+    max_duration: timedelta
+    """The maximum blocking duration."""
 
-    last_blocking_duration_sec: float = 0.0
-    """Last blocking duration (in seconds)."""
+    last_blocking_duration: timedelta = timedelta(seconds=0.0)
+    """Last blocking duration."""
 
     blocked_until: datetime | None = None
     """Until when the battery is blocked."""
 
     def __post_init__(self) -> None:
-        assert self.min_duration_sec <= self.max_duration_sec, (
-            f"Minimum blocking duration ({self.min_duration_sec}) cannot be greater "
-            f"than maximum blocking duration ({self.max_duration_sec})"
+        assert self.min_duration <= self.max_duration, (
+            f"Minimum blocking duration ({self.min_duration}) cannot be greater "
+            f"than maximum blocking duration ({self.max_duration})"
         )
-        self.last_blocking_duration_sec = self.min_duration_sec
+        self.last_blocking_duration = self.min_duration
 
-    def block(self) -> float:
+    def block(self) -> timedelta:
         """Block battery.
 
         Battery can be unblocked using `self.unblock()` method.
 
         Returns:
-            For how long (in seconds) the battery is blocked.
+            The duration for which the battery is blocked.
         """
         now = datetime.now(tz=timezone.utc)
 
         # If is not blocked
         if self.blocked_until is None:
-            self.last_blocking_duration_sec = self.min_duration_sec
-            self.blocked_until = now + timedelta(
-                seconds=self.last_blocking_duration_sec
-            )
-            return self.last_blocking_duration_sec
+            self.last_blocking_duration = self.min_duration
+            self.blocked_until = now + self.last_blocking_duration
+            return self.last_blocking_duration
 
         # If still blocked, then do nothing
         if self.blocked_until > now:
-            return 0.0
+            return timedelta(seconds=0.0)
 
         # If previous blocking time expired, then blocked it once again.
         # Increase last blocking time, unless it reach the maximum.
-        self.last_blocking_duration_sec = min(
-            2 * self.last_blocking_duration_sec, self.max_duration_sec
+        self.last_blocking_duration = min(
+            2 * self.last_blocking_duration, self.max_duration
         )
-        self.blocked_until = now + timedelta(seconds=self.last_blocking_duration_sec)
+        self.blocked_until = now + self.last_blocking_duration
 
-        return self.last_blocking_duration_sec
+        return self.last_blocking_duration
 
     def unblock(self) -> None:
         """Unblock battery.
@@ -166,20 +164,19 @@ class BatteryStatusTracker(ComponentStatusTracker):
     def __init__(  # pylint: disable=too-many-arguments
         self,
         component_id: int,
-        max_data_age_sec: float,
-        max_blocking_duration_sec: float,
+        max_data_age: timedelta,
+        max_blocking_duration: timedelta,
         status_sender: Sender[ComponentStatus],
         set_power_result_receiver: Receiver[SetPowerResult],
     ) -> None:
         """Create class instance.
 
         Args:
             component_id: Id of this battery
-            max_data_age_sec: If component stopped sending data, then
-                this is the maximum time when its last message should be considered as
-                valid. After that time, component won't be used until it starts sending
-                data.
-            max_blocking_duration_sec: This value tell what should be the maximum
+            max_data_age: If component stopped sending data, then this is the maximum
+                time when its last message should be considered as valid. After that
+                time, component won't be used until it starts sending data.
+            max_blocking_duration: This value tell what should be the maximum
                 timeout used for blocking failing component.
             status_sender: Channel to send status updates.
             set_power_result_receiver: Channel to receive results of the requests to the
@@ -188,12 +185,12 @@ def __init__(  # pylint: disable=too-many-arguments
         Raises:
             RuntimeError: If battery has no adjacent inverter.
         """
-        self._max_data_age = max_data_age_sec
+        self._max_data_age = max_data_age
         # First battery is considered as not working.
         # Change status after first messages are received.
         self._last_status: ComponentStatusEnum = ComponentStatusEnum.NOT_WORKING
         self._blocking_status: _BlockingStatus = _BlockingStatus(
-            1.0, max_blocking_duration_sec
+            timedelta(seconds=1.0), max_blocking_duration
         )
 
         inverter_id = self._find_adjacent_inverter_id(component_id)
@@ -204,11 +201,11 @@ def __init__(  # pylint: disable=too-many-arguments
 
         self._battery: _ComponentStreamStatus = _ComponentStreamStatus(
             component_id,
-            data_recv_timer=Timer.timeout(timedelta(seconds=max_data_age_sec)),
+            data_recv_timer=Timer.timeout(max_data_age),
         )
         self._inverter: _ComponentStreamStatus = _ComponentStreamStatus(
             inverter_id,
-            data_recv_timer=Timer.timeout(timedelta(seconds=max_data_age_sec)),
+            data_recv_timer=Timer.timeout(max_data_age),
         )
 
         # Select needs receivers that can be get in async way only.
@@ -259,9 +256,9 @@ def _handle_status_set_power_result(self, result: SetPowerResult) -> None:
         ):
             duration = self._blocking_status.block()
 
-            if duration > 0:
+            if duration > timedelta(seconds=0.0):
                 _logger.warning(
-                    "battery %d failed last response. block it for %f sec",
+                    "battery %d failed last response. block it for %s",
                     self.battery_id,
                     duration,
                 )
@@ -345,7 +342,7 @@ async def _run(
                         if (
                             datetime.now(tz=timezone.utc)
                             - self._battery.last_msg_timestamp
-                        ) < timedelta(seconds=self._max_data_age):
+                        ) < self._max_data_age:
                             # This means that we have received data from the battery
                             # since the timer triggered, but the timer event arrived
                             # late, so we can ignore it.
@@ -356,7 +353,7 @@ async def _run(
                         if (
                             datetime.now(tz=timezone.utc)
                             - self._inverter.last_msg_timestamp
-                        ) < timedelta(seconds=self._max_data_age):
+                        ) < self._max_data_age:
                             # This means that we have received data from the inverter
                             # since the timer triggered, but the timer event arrived
                             # late, so we can ignore it.
@@ -505,7 +502,7 @@ def _is_timestamp_outdated(self, timestamp: datetime) -> bool:
             _True if timestamp is to old, False otherwise
         """
         now = datetime.now(tz=timezone.utc)
-        diff = (now - timestamp).total_seconds()
+        diff = now - timestamp
         return diff > self._max_data_age
 
     def _is_message_reliable(self, message: ComponentData) -> bool:

src/frequenz/sdk/actor/power_distributing/_component_status/_component_status.py

@@ -8,6 +8,7 @@
 from abc import ABC, abstractmethod
 from collections import abc
 from dataclasses import dataclass
+from datetime import timedelta
 
 from frequenz.channels import Receiver, Sender
 
@@ -83,20 +84,19 @@ class ComponentStatusTracker(ABC):
     def __init__(  # pylint: disable=too-many-arguments
         self,
         component_id: int,
-        max_data_age_sec: float,
-        max_blocking_duration_sec: float,
+        max_data_age: timedelta,
+        max_blocking_duration: timedelta,
         status_sender: Sender[ComponentStatus],
         set_power_result_receiver: Receiver[SetPowerResult],
     ) -> None:
         """Create class instance.
 
         Args:
             component_id: Id of this component
-            max_data_age_sec: If component stopped sending data, then
-                this is the maximum time when its last message should be considered as
-                valid. After that time, component won't be used until it starts sending
-                data.
-            max_blocking_duration_sec: This value tell what should be the maximum
+            max_data_age: If component stopped sending data, then this is the maximum
+                time when its last message should be considered as valid. After that
+                time, component won't be used until it starts sending data.
+            max_blocking_duration: This value tell what should be the maximum
                 timeout used for blocking failing component.
             status_sender: Channel to send status updates.
             set_power_result_receiver: Channel to receive results of the requests to the

tests/actor/test_battery_pool_status.py

@@ -3,6 +3,7 @@
 """Tests for BatteryPoolStatus."""
 
 import asyncio
+from datetime import timedelta
 
 from frequenz.channels import Broadcast
 from pytest_mock import MockerFixture
@@ -47,8 +48,8 @@ async def test_batteries_status(self, mocker: MockerFixture) -> None:
             batteries_status = ComponentPoolStatusTracker(
                 component_ids=batteries,
                 component_status_sender=battery_status_channel.new_sender(),
-                max_data_age_sec=5,
-                max_blocking_duration_sec=30,
+                max_data_age=timedelta(seconds=5),
+                max_blocking_duration=timedelta(seconds=30),
                 component_status_tracker_type=BatteryStatusTracker,
             )
             await asyncio.sleep(0.1)

tests/actor/test_battery_status.py

@@ -188,8 +188,8 @@ async def test_sync_update_status_with_messages(
 
         async with mock_microgrid, battery_status_tracker(
             BATTERY_ID,
-            max_data_age_sec=5,
-            max_blocking_duration_sec=30,
+            max_data_age=timedelta(seconds=5),
+            max_blocking_duration=timedelta(seconds=30),
             status_sender=status_channel.new_sender(),
             set_power_result_receiver=set_power_result_channel.new_receiver(),
         ) as tracker:
@@ -358,8 +358,8 @@ async def test_sync_blocking_feature(self, mocker: MockerFixture) -> None:
             # increase max_data_age_sec for blocking tests.
             # Otherwise it will block blocking.
             BATTERY_ID,
-            max_data_age_sec=500,
-            max_blocking_duration_sec=30,
+            max_data_age=timedelta(seconds=500),
+            max_blocking_duration=timedelta(seconds=30),
             status_sender=status_channel.new_sender(),
             set_power_result_receiver=set_power_result_channel.new_receiver(),
         ) as tracker:
@@ -494,8 +494,8 @@ async def test_sync_blocking_interrupted_with_with_max_data(
 
         async with mock_microgrid, battery_status_tracker(
             BATTERY_ID,
-            max_data_age_sec=5,
-            max_blocking_duration_sec=30,
+            max_data_age=timedelta(seconds=5),
+            max_blocking_duration=timedelta(seconds=30),
             status_sender=status_channel.new_sender(),
             set_power_result_receiver=set_power_result_channel.new_receiver(),
         ) as tracker:
@@ -542,8 +542,8 @@ async def test_sync_blocking_interrupted_with_invalid_message(
 
         async with mock_microgrid, battery_status_tracker(
             BATTERY_ID,
-            max_data_age_sec=5,
-            max_blocking_duration_sec=30,
+            max_data_age=timedelta(seconds=5),
+            max_blocking_duration=timedelta(seconds=30),
             status_sender=status_channel.new_sender(),
             set_power_result_receiver=set_power_result_channel.new_receiver(),
         ) as tracker:
@@ -603,8 +603,8 @@ async def test_timers(
 
         async with mock_microgrid, battery_status_tracker(
             BATTERY_ID,
-            max_data_age_sec=5,
-            max_blocking_duration_sec=30,
+            max_data_age=timedelta(seconds=5),
+            max_blocking_duration=timedelta(seconds=30),
             status_sender=status_channel.new_sender(),
             set_power_result_receiver=set_power_result_channel.new_receiver(),
         ) as tracker:
@@ -669,8 +669,8 @@ async def test_async_battery_status(self, mocker: MockerFixture) -> None:
 
         async with mock_microgrid, battery_status_tracker(
             BATTERY_ID,
-            max_data_age_sec=5,
-            max_blocking_duration_sec=30,
+            max_data_age=timedelta(seconds=5),
+            max_blocking_duration=timedelta(seconds=30),
             status_sender=status_channel.new_sender(),
             set_power_result_receiver=set_power_result_channel.new_receiver(),
         ):
@@ -753,8 +753,8 @@ async def setup_tracker(
 
         async with mock_microgrid, battery_status_tracker(
             BATTERY_ID,
-            max_data_age_sec=0.1,
-            max_blocking_duration_sec=1,
+            max_data_age=timedelta(seconds=0.1),
+            max_blocking_duration=timedelta(seconds=1),
             status_sender=status_channel.new_sender(),
             set_power_result_receiver=set_power_result_channel.new_receiver(),
         ):