Rename some internal classes

... battery_status.py and battery_pool_status.py

Signed-off-by: ela-kotulska-frequenz <[email protected]>

Author: ela-kotulska-frequenz

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

@@ -13,7 +13,7 @@
 from frequenz.channels.util import MergeNamed
 
 from ..._internal.asyncio import cancel_and_await
-from ._battery_status import BatteryStatus, BatteryStatusTracker, RequestResult
+from ._battery_status import BatteryStatus, BatteryStatusTracker, SetPowerResult
 
 _logger = logging.getLogger(__name__)
 
@@ -94,7 +94,7 @@ def __init__(
         self._current_status = Status(working=set(), uncertain=set())
 
         # Channel for sending results of requests to the batteries
-        request_result_channel = Broadcast[RequestResult]("battery_request_status")
+        request_result_channel = Broadcast[SetPowerResult]("battery_request_status")
         self._request_result_sender = request_result_channel.new_sender()
 
         self._batteries: Dict[str, BatteryStatusTracker] = {}
@@ -179,7 +179,7 @@ async def update_status(
             failed_batteries: Batteries that failed request
         """
         await self._request_result_sender.send(
-            RequestResult(succeed_batteries, failed_batteries)
+            SetPowerResult(succeed_batteries, failed_batteries)
         )
 
     def get_working_batteries(self, batteries: Set[int]) -> Set[int]:

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

@@ -9,7 +9,7 @@
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from enum import Enum
-from typing import Generic, Iterable, Optional, Set, TypeVar, Union
+from typing import Iterable, Optional, Set, TypeVar, Union
 
 from frequenz.api.microgrid.battery_pb2 import ComponentState as BatteryComponentState
 from frequenz.api.microgrid.battery_pb2 import RelayState as BatteryRelayState
@@ -46,7 +46,7 @@ class BatteryStatus(Enum):
 
 
 @dataclass
-class RequestResult:
+class SetPowerResult:
     """Information what batteries succeed or failed the last request."""
 
     succeed: Iterable[int]
@@ -60,7 +60,7 @@ class RequestResult:
 
 
 @dataclass
-class _ComponentData(Generic[T]):
+class _ComponentStreamStatus:
     component_id: int
     last_msg_timestamp: datetime = datetime.now(tz=timezone.utc)
     last_msg_correct: bool = False
@@ -156,7 +156,7 @@ def __init__(  # pylint: disable=too-many-arguments
         max_data_age_sec: float,
         max_blocking_duration_sec: float,
         status_sender: Sender[BatteryStatus],
-        request_result_receiver: Receiver[RequestResult],
+        request_result_receiver: Receiver[SetPowerResult],
     ) -> None:
         """Create class instance.
 
@@ -185,8 +185,8 @@ def __init__(  # pylint: disable=too-many-arguments
         if inverter_id is None:
             raise RuntimeError(f"Can't find inverter adjacent to battery: {battery_id}")
 
-        self._battery = _ComponentData[BatteryData](battery_id)
-        self._inverter = _ComponentData[InverterData](inverter_id)
+        self._battery = _ComponentStreamStatus(battery_id)
+        self._inverter = _ComponentStreamStatus(inverter_id)
 
         # Select needs receivers that can be get in async way only.
         self._select = None
@@ -214,7 +214,7 @@ async def stop(self) -> None:
     async def _run(
         self,
         status_sender: Sender[BatteryStatus],
-        request_result_receiver: Receiver[RequestResult],
+        request_result_receiver: Receiver[SetPowerResult],
     ) -> None:
         """Process data from the components and request_result_receiver.
 
@@ -265,7 +265,7 @@ def _update_status(self, select: Select) -> Optional[BatteryStatus]:
             self._inverter.last_msg_timestamp = msg.inner.timestamp
 
         elif msg := select.request_result:
-            result: RequestResult = msg.inner
+            result: SetPowerResult = msg.inner
             if self.battery_id in result.succeed:
                 self._blocking_status.unblock()
 

tests/actor/test_battery_status.py

@@ -30,7 +30,7 @@
 from frequenz.sdk.actor.power_distributing._battery_status import (
     BatteryStatus,
     BatteryStatusTracker,
-    RequestResult,
+    SetPowerResult,
 )
 from frequenz.sdk.microgrid.client import Connection
 from frequenz.sdk.microgrid.component import (
@@ -194,14 +194,14 @@ def __init__(
         self,
         battery: Optional[BatteryData] = None,
         inverter: Optional[InverterData] = None,
-        request_result: Optional[RequestResult] = None,
+        request_result: Optional[SetPowerResult] = None,
     ) -> None:
         """Create FakeSelect instance
 
         Args:
             battery: Expected battery message. Defaults to None.
             inverter: Expected inverter message. Defaults to None.
-            request_result: Expected RequestResult message. Defaults to None.
+            request_result: Expected SetPowerResult message. Defaults to None.
         """
         self.battery = None if battery is None else Message(battery)
         self.inverter = None if inverter is None else Message(inverter)
@@ -245,7 +245,7 @@ async def test_sync_update_status_with_messages(
             mock_microgrid: mock_microgrid fixture
         """
         status_channel = Broadcast[BatteryStatus]("battery_status")
-        request_result_channel = Broadcast[RequestResult]("request_result")
+        request_result_channel = Broadcast[SetPowerResult]("request_result")
 
         tracker = BatteryStatusTracker(
             BATTERY_ID,
@@ -382,7 +382,7 @@ async def test_sync_update_status_with_messages(
     async def test_sync_blocking_feature(
         self, mock_microgrid: MockMicrogridClient
     ) -> None:
-        """Test if status changes when RequestResult message is received.
+        """Test if status changes when SetPowerResult message is received.
 
         Tests uses FakeSelect to test status in sync way.
         Otherwise we would have lots of async calls and waiting.
@@ -392,7 +392,7 @@ async def test_sync_blocking_feature(
         """
 
         status_channel = Broadcast[BatteryStatus]("battery_status")
-        request_result_channel = Broadcast[RequestResult]("request_result")
+        request_result_channel = Broadcast[SetPowerResult]("request_result")
 
         # increase max_data_age_sec for blocking tests.
         # Otherwise it will block blocking.
@@ -417,7 +417,9 @@ async def test_sync_blocking_feature(
             assert tracker._update_status(select) is None  # type: ignore[arg-type]
 
             # message is not correct, component should not block.
-            select = FakeSelect(request_result=RequestResult(succeed={1}, failed={106}))
+            select = FakeSelect(
+                request_result=SetPowerResult(succeed={1}, failed={106})
+            )
             assert tracker._update_status(select) is None  # type: ignore[arg-type]
 
             select = FakeSelect(battery=battery_data(component_id=BATTERY_ID))
@@ -428,15 +430,15 @@ async def test_sync_blocking_feature(
             for timeout in expected_blocking_timeout:
                 # message is not correct, component should not block.
                 select = FakeSelect(
-                    request_result=RequestResult(succeed={1}, failed={106})
+                    request_result=SetPowerResult(succeed={1}, failed={106})
                 )
                 status = tracker._update_status(select)  # type: ignore[arg-type]
                 assert status is BatteryStatus.UNCERTAIN
 
                 # Battery should be still blocked, nothing should happen
                 time.shift(timeout - 1)
                 select = FakeSelect(
-                    request_result=RequestResult(succeed={1}, failed={106})
+                    request_result=SetPowerResult(succeed={1}, failed={106})
                 )
                 assert tracker._update_status(select) is None  # type: ignore[arg-type]
 
@@ -449,7 +451,9 @@ async def test_sync_blocking_feature(
                 assert status is BatteryStatus.WORKING
 
             # should block for 30 sec
-            select = FakeSelect(request_result=RequestResult(succeed={1}, failed={106}))
+            select = FakeSelect(
+                request_result=SetPowerResult(succeed={1}, failed={106})
+            )
             status = tracker._update_status(select)  # type: ignore[arg-type]
             assert status is BatteryStatus.UNCERTAIN
             time.shift(28)
@@ -469,14 +473,16 @@ async def test_sync_blocking_feature(
             assert status is BatteryStatus.WORKING
 
             # should block for 30 sec
-            select = FakeSelect(request_result=RequestResult(succeed={1}, failed={106}))
+            select = FakeSelect(
+                request_result=SetPowerResult(succeed={1}, failed={106})
+            )
             status = tracker._update_status(select)  # type: ignore[arg-type]
             assert status is BatteryStatus.UNCERTAIN
             time.shift(28)
 
             # If battery succeed, then it should unblock.
             select = FakeSelect(
-                request_result=RequestResult(succeed={106}, failed={206})
+                request_result=SetPowerResult(succeed={106}, failed={206})
             )
             status = tracker._update_status(select)  # type: ignore[arg-type]
             assert status is BatteryStatus.WORKING
@@ -486,7 +492,7 @@ async def test_sync_blocking_feature(
     async def test_sync_blocking_interrupted_with_with_max_data(
         self, mock_microgrid: MockMicrogridClient
     ) -> None:
-        """Test if status changes when RequestResult message is received.
+        """Test if status changes when SetPowerResult message is received.
 
         Tests uses FakeSelect to test status in sync way.
         Otherwise we would have lots of async calls and waiting.
@@ -496,7 +502,7 @@ async def test_sync_blocking_interrupted_with_with_max_data(
         """
 
         status_channel = Broadcast[BatteryStatus]("battery_status")
-        request_result_channel = Broadcast[RequestResult]("request_result")
+        request_result_channel = Broadcast[SetPowerResult]("request_result")
 
         tracker = BatteryStatusTracker(
             BATTERY_ID,
@@ -514,21 +520,25 @@ async def test_sync_blocking_interrupted_with_with_max_data(
             status = tracker._update_status(select)  # type: ignore[arg-type]
             assert status is BatteryStatus.WORKING
 
-            select = FakeSelect(request_result=RequestResult(succeed={1}, failed={106}))
+            select = FakeSelect(
+                request_result=SetPowerResult(succeed={1}, failed={106})
+            )
             status = tracker._update_status(select)  # type: ignore[arg-type]
             assert status is BatteryStatus.UNCERTAIN
 
             expected_blocking_timeout = [1, 2, 4]
             for timeout in expected_blocking_timeout:
                 # message is not correct, component should not block.
                 select = FakeSelect(
-                    request_result=RequestResult(succeed={1}, failed={106})
+                    request_result=SetPowerResult(succeed={1}, failed={106})
                 )
                 assert tracker._update_status(select) is None  # type: ignore[arg-type]
                 time.shift(timeout)
 
             # Battery message should be to old after 5 seconds.
-            select = FakeSelect(request_result=RequestResult(succeed={1}, failed={106}))
+            select = FakeSelect(
+                request_result=SetPowerResult(succeed={1}, failed={106})
+            )
             status = tracker._update_status(select)  # type: ignore[arg-type]
             assert status is BatteryStatus.NOT_WORKING
 
@@ -538,7 +548,7 @@ async def test_sync_blocking_interrupted_with_with_max_data(
     async def test_sync_blocking_interrupted_with_invalid_message(
         self, mock_microgrid: MockMicrogridClient
     ) -> None:
-        """Test if status changes when RequestResult message is received.
+        """Test if status changes when SetPowerResult message is received.
 
         Tests uses FakeSelect to test status in sync way.
         Otherwise we would have lots of async calls and waiting.
@@ -548,7 +558,7 @@ async def test_sync_blocking_interrupted_with_invalid_message(
         """
 
         status_channel = Broadcast[BatteryStatus]("battery_status")
-        request_result_channel = Broadcast[RequestResult]("request_result")
+        request_result_channel = Broadcast[SetPowerResult]("request_result")
 
         tracker = BatteryStatusTracker(
             BATTERY_ID,
@@ -564,7 +574,7 @@ async def test_sync_blocking_interrupted_with_invalid_message(
         select = FakeSelect(battery=battery_data(component_id=BATTERY_ID))
         assert tracker._update_status(select) is BatteryStatus.WORKING  # type: ignore[arg-type]
 
-        select = FakeSelect(request_result=RequestResult(succeed={1}, failed={106}))
+        select = FakeSelect(request_result=SetPowerResult(succeed={1}, failed={106}))
         assert tracker._update_status(select) is BatteryStatus.UNCERTAIN  # type: ignore[arg-type]
 
         select = FakeSelect(
@@ -575,10 +585,10 @@ async def test_sync_blocking_interrupted_with_invalid_message(
         )
         assert tracker._update_status(select) is BatteryStatus.NOT_WORKING  # type: ignore[arg-type]
 
-        select = FakeSelect(request_result=RequestResult(succeed={1}, failed={106}))
+        select = FakeSelect(request_result=SetPowerResult(succeed={1}, failed={106}))
         assert tracker._update_status(select) is None  # type: ignore[arg-type]
 
-        select = FakeSelect(request_result=RequestResult(succeed={106}, failed={}))
+        select = FakeSelect(request_result=SetPowerResult(succeed={106}, failed={}))
         assert tracker._update_status(select) is None  # type: ignore[arg-type]
 
         select = FakeSelect(inverter=inverter_data(component_id=INVERTER_ID))
@@ -597,7 +607,7 @@ async def test_async_battery_status(
         """
 
         status_channel = Broadcast[BatteryStatus]("battery_status")
-        request_result_channel = Broadcast[RequestResult]("request_result")
+        request_result_channel = Broadcast[SetPowerResult]("request_result")
 
         status_receiver = status_channel.new_receiver()
         request_result_sender = request_result_channel.new_sender()
@@ -618,7 +628,7 @@ async def test_async_battery_status(
             assert status is BatteryStatus.WORKING
 
             assert await request_result_sender.send(
-                RequestResult(succeed={}, failed={BATTERY_ID})
+                SetPowerResult(succeed={}, failed={BATTERY_ID})
             )
             status = await asyncio.wait_for(status_receiver.receive(), timeout=0.1)
             assert status is BatteryStatus.UNCERTAIN
@@ -639,7 +649,7 @@ async def test_async_battery_status(
             assert status is BatteryStatus.NOT_WORKING
 
             assert await request_result_sender.send(
-                RequestResult(succeed={}, failed={BATTERY_ID})
+                SetPowerResult(succeed={}, failed={BATTERY_ID})
             )
             await asyncio.sleep(0.3)
             assert len(status_receiver) == 0