Rename mappings to use consistent plural

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

Author: Marenz

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

@@ -130,8 +130,8 @@ def __init__(
         """The distribution algorithm used to distribute power between batteries."""
 
         (
-            self._bat_inv_map,
-            self._inv_bat_map,
+            self._bat_invs_map,
+            self._inv_bats_map,
             self._bat_bats_map,
             self._inv_invs_map,
         ) = self._get_components_pairs(connection_manager.get().component_graph)
@@ -140,7 +140,7 @@ def __init__(
         self._inverter_receivers: dict[int, Peekable[InverterData]] = {}
 
         self._all_battery_status = BatteryPoolStatus(
-            battery_ids=set(self._bat_inv_map.keys()),
+            battery_ids=set(self._bat_invs_map.keys()),
             battery_status_sender=battery_status_sender,
             max_blocking_duration_sec=30.0,
             max_data_age_sec=10.0,
@@ -252,7 +252,7 @@ async def _run(self) -> None:  # pylint: disable=too-many-locals
             )
             battery_distribution: dict[int, float] = {}
             for inverter_id, dist in distribution.distribution.items():
-                for battery_id in self._inv_bat_map[inverter_id]:
+                for battery_id in self._inv_bats_map[inverter_id]:
                     battery_distribution[battery_id] = (
                         battery_distribution.get(battery_id, 0.0) + dist
                     )
@@ -348,7 +348,7 @@ def _get_power_distribution(
         unavailable_inv_ids: set[int] = set()
 
         for inverter_ids in [
-            self._bat_inv_map[battery_id_set] for battery_id_set in unavailable_bat_ids
+            self._bat_invs_map[battery_id_set] for battery_id_set in unavailable_bat_ids
         ]:
             unavailable_inv_ids = unavailable_inv_ids.union(inverter_ids)
 
@@ -429,8 +429,8 @@ def _get_components_pairs(
                 battery to batteries,
                 inverter to inverters.
         """
-        bat_inv_map: dict[int, set[int]] = {}
-        inv_bat_map: dict[int, set[int]] = {}
+        bat_invs_map: dict[int, set[int]] = {}
+        inv_bats_map: dict[int, set[int]] = {}
         bat_bats_map: dict[int, set[int]] = {}
         inv_invs_map: dict[int, set[int]] = {}
 
@@ -453,7 +453,7 @@ def _get_components_pairs(
                 "Battery %d has inverter %s", battery.component_id, list(inverters)
             )
 
-            bat_inv_map[battery.component_id] = inverters
+            bat_invs_map[battery.component_id] = inverters
             bat_bats_map.setdefault(battery.component_id, set()).update(
                 set(
                     component.component_id
@@ -463,13 +463,13 @@ def _get_components_pairs(
             )
 
             for inverter in inverters:
-                inv_bat_map.setdefault(inverter, set()).add(battery.component_id)
-                inv_invs_map.setdefault(inverter, set()).update(bat_inv_map)
+                inv_bats_map.setdefault(inverter, set()).add(battery.component_id)
+                inv_invs_map.setdefault(inverter, set()).update(bat_invs_map)
 
         # Convert sets to frozensets to make them hashable.
         return (
-            {k: frozenset(v) for k, v in bat_inv_map.items()},
-            {k: frozenset(v) for k, v in inv_bat_map.items()},
+            {k: frozenset(v) for k, v in bat_invs_map.items()},
+            {k: frozenset(v) for k, v in inv_bats_map.items()},
             {k: frozenset(v) for k, v in bat_bats_map.items()},
             {k: frozenset(v) for k, v in inv_invs_map.items()},
         )
@@ -518,7 +518,7 @@ def _get_components_data(self, batteries: abc.Set[int]) -> list[InvBatPair]:
         )
 
         for battery_ids in battery_sets:
-            inverter_ids: frozenset[int] = self._bat_inv_map[next(iter(battery_ids))]
+            inverter_ids: frozenset[int] = self._bat_invs_map[next(iter(battery_ids))]
 
             data = self._get_battery_inverter_data(battery_ids, inverter_ids)
             if data is None:
@@ -610,7 +610,7 @@ def nan_metric_in_list(data: list[DataType], metrics: list[str]) -> bool:
     async def _create_channels(self) -> None:
         """Create channels to get data of components in microgrid."""
         api = connection_manager.get().api_client
-        for battery_id, inverter_ids in self._bat_inv_map.items():
+        for battery_id, inverter_ids in self._bat_invs_map.items():
             bat_recv: Receiver[BatteryData] = await api.battery_data(battery_id)
             self._battery_receivers[battery_id] = bat_recv.into_peekable()
 
@@ -644,7 +644,7 @@ def _parse_result(
         failed_batteries: set[int] = set()
 
         for inverter_id, aws in tasks.items():
-            battery_ids = self._inv_bat_map[inverter_id]
+            battery_ids = self._inv_bats_map[inverter_id]
             try:
                 aws.result()
             except grpc.aio.AioRpcError as err:

tests/actor/power_distributing/test_power_distributing.py

@@ -61,8 +61,8 @@ async def test_constructor(self, mocker: MockerFixture) -> None:
             results_sender=results_channel.new_sender(),
             battery_status_sender=battery_status_channel.new_sender(),
         ) as distributor:
-            assert distributor._bat_inv_map == {9: {8}, 19: {18}, 29: {28}}
-            assert distributor._inv_bat_map == {8: {9}, 18: {19}, 28: {29}}
+            assert distributor._bat_invs_map == {9: {8}, 19: {18}, 29: {28}}
+            assert distributor._inv_bats_map == {8: {9}, 18: {19}, 28: {29}}
         await mockgrid.cleanup()
 
         # Test if it works without grid side meter
@@ -75,8 +75,8 @@ async def test_constructor(self, mocker: MockerFixture) -> None:
             results_sender=results_channel.new_sender(),
             battery_status_sender=battery_status_channel.new_sender(),
         ) as distributor:
-            assert distributor._bat_inv_map == {9: {8}, 19: {18}, 29: {28}}
-            assert distributor._inv_bat_map == {8: {9}, 18: {19}, 28: {29}}
+            assert distributor._bat_invs_map == {9: {8}, 19: {18}, 29: {28}}
+            assert distributor._inv_bats_map == {8: {9}, 18: {19}, 28: {29}}
         await mockgrid.cleanup()
 
     async def init_component_data(

tests/timeseries/_battery_pool/test_battery_pool.py

@@ -1181,9 +1181,9 @@ async def run_temperature_test(  # pylint: disable=too-many-locals
     await battery_status_sender.send(
         BatteryStatus(working=all_batteries, uncertain=set())
     )
-    bat_inv_map = battery_inverter_mapping(all_batteries)
+    bat_invs_map = battery_inverter_mapping(all_batteries)
 
-    for battery_id, inverter_id in bat_inv_map.items():
+    for battery_id, inverter_id in bat_invs_map.items():
         # Sampling rate choose to reflect real application.
         streamer.start_streaming(
             BatteryDataWrapper(