Switch class names in battery_pool_status and battery_status

BatteryStatus will be used outside, by users.
Status is just an internal class.

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

Author: ela-kotulska-frequenz

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

@@ -13,13 +13,13 @@
 from frequenz.channels.util import MergeNamed
 
 from ..._internal.asyncio import cancel_and_await
-from ._battery_status import BatteryStatus, BatteryStatusTracker, SetPowerResult
+from ._battery_status import BatteryStatusTracker, SetPowerResult, Status
 
 _logger = logging.getLogger(__name__)
 
 
 @dataclass
-class Status:
+class BatteryStatus:
     """Status of the batteries."""
 
     working: Set[int]
@@ -56,7 +56,7 @@ class _BatteryStatusChannelHelper:
 
     def __post_init__(self):
         self.name: str = f"battery-{self.battery_id}-status"
-        channel = Broadcast[BatteryStatus](self.name)
+        channel = Broadcast[Status](self.name)
 
         receiver_name = f"{self.name}-receiver"
         self.receiver = channel.new_receiver(name=receiver_name, maxsize=1)
@@ -91,7 +91,7 @@ def __init__(
         """
         # At first no battery is working, we will get notification when they start
         # working.
-        self._current_status = Status(working=set(), uncertain=set())
+        self._current_status = BatteryStatus(working=set(), uncertain=set())
 
         # Channel for sending results of requests to the batteries
         request_result_channel = Broadcast[SetPowerResult]("battery_request_status")
@@ -101,7 +101,7 @@ def __init__(
 
         # Receivers for individual battery statuses are needed to create a `MergeNamed`
         # object.
-        receivers: Dict[str, Receiver[BatteryStatus]] = {}
+        receivers: Dict[str, Receiver[Status]] = {}
 
         for battery_id in battery_ids:
             channel = _BatteryStatusChannelHelper(battery_id)
@@ -117,7 +117,7 @@ def __init__(
                 ),
             )
 
-        self._battery_status_channel = MergeNamed[BatteryStatus](
+        self._battery_status_channel = MergeNamed[Status](
             **receivers,
         )
 
@@ -145,21 +145,21 @@ async def _run(self) -> None:
                     "BatteryPoolStatus failed with error: %s. Restarting.", err
                 )
 
-    async def _update_status(self, status_channel: MergeNamed[BatteryStatus]) -> None:
+    async def _update_status(self, status_channel: MergeNamed[Status]) -> None:
         """Wait for any battery to change status and update status.
 
         Args:
             status_channel: Receivers packed in Select object.
         """
         async for channel_name, status in status_channel:
             battery_id = self._batteries[channel_name].battery_id
-            if status == BatteryStatus.WORKING:
+            if status == Status.WORKING:
                 self._current_status.working.add(battery_id)
                 self._current_status.uncertain.discard(battery_id)
-            elif status == BatteryStatus.UNCERTAIN:
+            elif status == Status.UNCERTAIN:
                 self._current_status.working.discard(battery_id)
                 self._current_status.uncertain.add(battery_id)
-            elif status == BatteryStatus.NOT_WORKING:
+            elif status == Status.NOT_WORKING:
                 self._current_status.working.discard(battery_id)
                 self._current_status.uncertain.discard(battery_id)
 

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

@@ -30,7 +30,7 @@
 _logger = logging.getLogger(__name__)
 
 
-class BatteryStatus(Enum):
+class Status(Enum):
     """Tells if battery is can be used."""
 
     NOT_WORKING = 0
@@ -155,7 +155,7 @@ def __init__(  # pylint: disable=too-many-arguments
         battery_id: int,
         max_data_age_sec: float,
         max_blocking_duration_sec: float,
-        status_sender: Sender[BatteryStatus],
+        status_sender: Sender[Status],
         request_result_receiver: Receiver[SetPowerResult],
     ) -> None:
         """Create class instance.
@@ -178,7 +178,7 @@ def __init__(  # pylint: disable=too-many-arguments
         self._max_data_age = max_data_age_sec
         # First battery is considered as not working.
         # Change status after first messages are received.
-        self._last_status = BatteryStatus.NOT_WORKING
+        self._last_status = Status.NOT_WORKING
         self._blocking_status = _BlockingStatus(1.0, max_blocking_duration_sec)
 
         inverter_id = self._find_adjacent_inverter_id(battery_id)
@@ -213,7 +213,7 @@ async def stop(self) -> None:
 
     async def _run(
         self,
-        status_sender: Sender[BatteryStatus],
+        status_sender: Sender[Status],
         request_result_receiver: Receiver[SetPowerResult],
     ) -> None:
         """Process data from the components and request_result_receiver.
@@ -247,7 +247,7 @@ async def _run(
             except Exception as err:  # pylint: disable=broad-except
                 _logger.exception("BatteryStatusTracker crashed with error: %s", err)
 
-    def _update_status(self, select: Select) -> Optional[BatteryStatus]:
+    def _update_status(self, select: Select) -> Optional[Status]:
         if msg := select.battery:
             self._battery.last_msg_correct = (
                 self._is_message_reliable(msg.inner)
@@ -309,7 +309,7 @@ def _update_status(self, select: Select) -> Optional[BatteryStatus]:
 
         return None
 
-    def _get_current_status(self) -> BatteryStatus:
+    def _get_current_status(self) -> Status:
         """Get current battery status.
 
         Returns:
@@ -320,15 +320,15 @@ def _get_current_status(self) -> BatteryStatus:
         )
 
         if not is_msg_correct:
-            return BatteryStatus.NOT_WORKING
-        if self._last_status == BatteryStatus.NOT_WORKING:
+            return Status.NOT_WORKING
+        if self._last_status == Status.NOT_WORKING:
             # If message just become correct, then try to use it
             self._blocking_status.unblock()
-            return BatteryStatus.WORKING
+            return Status.WORKING
         if self._blocking_status.is_blocked():
-            return BatteryStatus.UNCERTAIN
+            return Status.UNCERTAIN
 
-        return BatteryStatus.WORKING
+        return Status.WORKING
 
     def _no_critical_error(self, msg: Union[BatteryData, InverterData]) -> bool:
         """Check if battery or inverter message has any critical error.
@@ -343,7 +343,7 @@ def _no_critical_error(self, msg: Union[BatteryData, InverterData]) -> bool:
         # pylint: disable=protected-access
         critical_err = next((err for err in msg._errors if err.level == critical), None)
         if critical_err is not None:
-            if self._last_status == BatteryStatus.WORKING:
+            if self._last_status == Status.WORKING:
                 _logger.warning(
                     "Component %d has critical error: %s",
                     msg.component_id,
@@ -365,7 +365,7 @@ def _is_inverter_state_correct(self, msg: InverterData) -> bool:
         # pylint: disable=protected-access
         state = msg._component_state
         if state not in BatteryStatusTracker._inverter_valid_state:
-            if self._last_status == BatteryStatus.WORKING:
+            if self._last_status == Status.WORKING:
                 _logger.warning(
                     "Inverter %d has invalid state: %s",
                     msg.component_id,
@@ -387,7 +387,7 @@ def _is_battery_state_correct(self, msg: BatteryData) -> bool:
         # pylint: disable=protected-access
         state = msg._component_state
         if state not in BatteryStatusTracker._battery_valid_state:
-            if self._last_status == BatteryStatus.WORKING:
+            if self._last_status == Status.WORKING:
                 _logger.warning(
                     "Battery %d has invalid state: %s",
                     self.battery_id,
@@ -399,7 +399,7 @@ def _is_battery_state_correct(self, msg: BatteryData) -> bool:
         # pylint: disable=protected-access
         relay_state = msg._relay_state
         if relay_state not in BatteryStatusTracker._battery_valid_relay:
-            if self._last_status == BatteryStatus.WORKING:
+            if self._last_status == Status.WORKING:
                 _logger.warning(
                     "Battery %d has invalid relay state: %s",
                     self.battery_id,
@@ -432,7 +432,7 @@ def _is_message_reliable(self, message: ComponentData) -> bool:
         """
         is_outdated = self._is_timestamp_outdated(message.timestamp)
 
-        if is_outdated and self._last_status == BatteryStatus.WORKING:
+        if is_outdated and self._last_status == Status.WORKING:
             _logger.warning(
                 "Component %d stopped sending data. Last timestamp: %s.",
                 message.component_id,