Replace batteries → components in PowerDistributor's result types

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

Author: shsms

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

@@ -356,17 +356,17 @@ async def _run(self) -> None:  # pylint: disable=too-many-locals
                     succeeded_power=Power.from_watts(
                         distributed_power_value - failed_power
                     ),
-                    succeeded_batteries=succeed_batteries,
+                    succeeded_components=succeed_batteries,
                     failed_power=Power.from_watts(failed_power),
-                    failed_batteries=failed_batteries,
+                    failed_components=failed_batteries,
                     excess_power=Power.from_watts(distribution.remaining_power),
                 )
             else:
                 succeed_batteries = set(battery_distribution.keys())
                 response = Success(
                     request=request,
                     succeeded_power=Power.from_watts(distributed_power_value),
-                    succeeded_batteries=succeed_batteries,
+                    succeeded_components=succeed_batteries,
                     excess_power=Power.from_watts(distribution.remaining_power),
                 )
 

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

@@ -22,13 +22,13 @@ class _BaseResultMixin:
 
 @dataclasses.dataclass
 class _BaseSuccessMixin:
-    """Result returned when setting the power succeed for all batteries."""
+    """Result returned when setting the power succeed for all components."""
 
     succeeded_power: Power
     """The part of the requested power that was successfully set."""
 
-    succeeded_batteries: abc.Set[int]
-    """The subset of batteries for which power was set successfully."""
+    succeeded_components: abc.Set[int]
+    """The subset of components for which power was set successfully."""
 
     excess_power: Power
     """The part of the requested power that could not be fulfilled.
@@ -45,17 +45,17 @@ class _BaseSuccessMixin:
 
 @dataclasses.dataclass
 class Success(_BaseSuccessMixin, _BaseResultMixin):  # Order matters here. See above.
-    """Result returned when setting the power succeeded for all batteries."""
+    """Result returned when setting the power was successful for all components."""
 
 
 @dataclasses.dataclass
 class PartialFailure(_BaseSuccessMixin, _BaseResultMixin):
-    """Result returned when any battery failed to perform the request."""
+    """Result returned when some of the components had an error setting the power."""
 
     failed_power: Power
     """The part of the requested power that failed to be set."""
 
-    failed_batteries: abc.Set[int]
+    failed_components: abc.Set[int]
     """The subset of batteries for which the request failed."""
 
 
@@ -69,31 +69,31 @@ class Error(_BaseResultMixin):
 
 @dataclasses.dataclass
 class PowerBounds:
-    """Inclusion and exclusion power bounds for requested batteries."""
+    """Inclusion and exclusion power bounds for the requested components."""
 
     inclusion_lower: float
-    """The lower value of the inclusion power bounds for the requested batteries."""
+    """The lower value of the inclusion power bounds for the requested components."""
 
     exclusion_lower: float
-    """The lower value of the exclusion power bounds for the requested batteries."""
+    """The lower value of the exclusion power bounds for the requested components."""
 
     exclusion_upper: float
-    """The upper value of the exclusion power bounds for the requested batteries."""
+    """The upper value of the exclusion power bounds for the requested components."""
 
     inclusion_upper: float
-    """The upper value of the inclusion power bounds for the requested batteries."""
+    """The upper value of the inclusion power bounds for the requested components."""
 
 
 @dataclasses.dataclass
 class OutOfBounds(_BaseResultMixin):
     """Result returned when the power was not set because it was out of bounds.
 
     This result happens when the originating request was done with
-    `adjust_power = False` and the requested power is not within the batteries bounds.
+    `adjust_power = False` and the requested power is not within the available bounds.
     """
 
     bounds: PowerBounds
-    """The power bounds for the requested batteries.
+    """The power bounds for the requested components.
 
     If the requested power negative, then this value is the lower bound.
     Otherwise it is upper bound.
@@ -135,26 +135,26 @@ def handle_power_request_result(result: Result) -> None:
     request = Request(
         namespace="TestChannel",
         power=Power.from_watts(123.4),
-        batteries={8, 18},
+        component_ids={8, 18},
     )
 
     results: list[Result] = [
         Success(
             request,
             succeeded_power=Power.from_watts(123.4),
-            succeeded_batteries={8, 18},
+            succeeded_components={8, 18},
             excess_power=Power.zero(),
         ),
         PartialFailure(
             request,
             succeeded_power=Power.from_watts(103.4),
-            succeeded_batteries={8},
+            succeeded_components={8},
             excess_power=Power.zero(),
-            failed_batteries={18},
+            failed_components={18},
             failed_power=Power.from_watts(20.0),
         ),
         OutOfBounds(request, bounds=PowerBounds(0, 0, 0, 800)),
-        Error(request, msg="The batteries are not available"),
+        Error(request, msg="The components are not available"),
     ]
 
     for r in results:

tests/actor/power_distributing/test_power_distributing.py

@@ -864,7 +864,7 @@ async def test_battery_soc_nan(self, mocker: MockerFixture) -> None:
 
         result: Result = done.pop().result()
         assert isinstance(result, Success)
-        assert result.succeeded_batteries == {19}
+        assert result.succeeded_components == {19}
         assert result.succeeded_power.isclose(Power.from_watts(500.0))
         assert result.excess_power.isclose(Power.from_watts(700.0))
         assert result.request == request
@@ -921,7 +921,7 @@ async def test_battery_capacity_nan(self, mocker: MockerFixture) -> None:
 
         result: Result = done.pop().result()
         assert isinstance(result, Success)
-        assert result.succeeded_batteries == {19}
+        assert result.succeeded_components == {19}
         assert result.succeeded_power.isclose(Power.from_watts(500.0))
         assert result.excess_power.isclose(Power.from_watts(700.0))
         assert result.request == request
@@ -993,7 +993,7 @@ async def test_battery_power_bounds_nan(self, mocker: MockerFixture) -> None:
 
         result: Result = done.pop().result()
         assert isinstance(result, Success)
-        assert result.succeeded_batteries == {19}
+        assert result.succeeded_components == {19}
         assert result.succeeded_power.isclose(Power.from_kilowatts(1.0))
         assert result.excess_power.isclose(Power.from_watts(200.0))
         assert result.request == request
@@ -1247,7 +1247,7 @@ async def test_not_all_batteries_are_working(self, mocker: MockerFixture) -> Non
             assert len(done) == 1
             result = done.pop().result()
             assert isinstance(result, Success)
-            assert result.succeeded_batteries == {19}
+            assert result.succeeded_components == {19}
             assert result.excess_power.isclose(Power.from_watts(700.0))
             assert result.succeeded_power.isclose(Power.from_watts(500.0))
             assert result.request == request
@@ -1307,8 +1307,8 @@ async def test_partial_failure_result(self, mocker: MockerFixture) -> None:
             assert len(done) == 1
             result = done.pop().result()
             assert isinstance(result, PartialFailure)
-            assert result.succeeded_batteries == batteries - failed_batteries
-            assert result.failed_batteries == failed_batteries
+            assert result.succeeded_components == batteries - failed_batteries
+            assert result.failed_components == failed_batteries
             assert result.succeeded_power.isclose(Power.from_watts(1000.0))
             assert result.failed_power.isclose(Power.from_watts(failed_power))
             assert result.excess_power.isclose(Power.from_watts(200.0))

tests/timeseries/_battery_pool/test_battery_pool_control_methods.py

@@ -243,7 +243,7 @@ async def side_effect(inv_id: int, _: float) -> None:
             expected_result_pred=lambda result: isinstance(
                 result, power_distributing.PartialFailure
             )
-            and result.failed_batteries == {mocks.microgrid.battery_ids[0]},
+            and result.failed_components == {mocks.microgrid.battery_ids[0]},
         )
 
         # There should be an automatic retry.