fixup-WIP

Author: llucax

pyproject.toml

@@ -31,7 +31,7 @@ dependencies = [
   # (plugins.mkdocstrings.handlers.python.import)
   #"frequenz-client-microgrid >= 0.18.0, < 0.19.0",
   "frequenz-client-microgrid @ git+https://github.com/frequenz-floss/frequenz-client-microgrid-python@refs/heads/v0.18.x",
-  "frequenz-client-common >= 0.3.2, < 0.4.0",
+  "frequenz-client-common >= 0.3.6, < 0.4.0",
   "frequenz-channels >= 1.6.1, < 2.0.0",
   "frequenz-quantities[marshmallow] >= 1.0.0, < 2.0.0",
   "networkx >= 2.8, < 4",

tests/timeseries/_pv_pool/test_pv_pool_control_methods.py

@@ -17,6 +17,7 @@
 from pytest_mock import MockerFixture
 
 from frequenz.sdk import microgrid
+from frequenz.sdk.microgrid import _power_distributing
 from frequenz.sdk.microgrid._data_pipeline import _DataPipeline
 from frequenz.sdk.timeseries import ResamplerConfig2
 from frequenz.sdk.timeseries.pv_pool import PVPoolReport
@@ -75,8 +76,6 @@ async def _init_pv_inverters(self, mocks: _Mocks) -> None:
                     active_power=0.0,
                     active_power_inclusion_lower_bound=-10000.0 * (idx + 1),
                     active_power_inclusion_upper_bound=0.0,
-                    active_power_exclusion_lower_bound=0.0,
-                    active_power_exclusion_upper_bound=0.0,
                 ),
                 0.05,
             )
@@ -98,25 +97,30 @@ async def _fail_pv_inverters(
                     active_power=0.0,
                     active_power_inclusion_lower_bound=-10000.0 * (idx + 1),
                     active_power_inclusion_upper_bound=0.0,
-                    active_power_exclusion_lower_bound=0.0,
-                    active_power_exclusion_upper_bound=0.0,
                 ),
             )
 
-    def _assert_report(
+    def _assert_report(  # pylint: disable=too-many-arguments
         self,
         report: PVPoolReport | None,
         *,
         power: float | None,
         lower: float,
         upper: float,
+        dist_result: _power_distributing.Result | None = None,
+        expected_result_pred: (
+            typing.Callable[[_power_distributing.Result], bool] | None
+        ) = None,
     ) -> None:
         assert report is not None and report.target_power == (
             Power.from_watts(power) if power is not None else None
         )
         assert report.bounds is not None
         assert report.bounds.lower == Power.from_watts(lower)
         assert report.bounds.upper == Power.from_watts(upper)
+        if expected_result_pred is not None:
+            assert dist_result is not None
+            assert expected_result_pred(dist_result)
 
     async def _recv_reports_until(
         self,
@@ -126,13 +130,16 @@ async def _recv_reports_until(
         """Receive reports until the given condition is met."""
         max_reports = 10
         ctr = 0
+        latest_report: PVPoolReport | None = None
         while ctr < max_reports:
             ctr += 1
-            async with asyncio.timeout(10.0):
-                report = await bounds_rx.receive()
-            if check(report):
-                return report
-        return None
+            print(f"[TEST] Waiting for report #{ctr}...")
+            latest_report = await bounds_rx.receive()
+            print(f"[TEST] Received report #{ctr}: {latest_report}")
+            if check(latest_report):
+                break
+
+        return latest_report
 
     async def test_setting_power(  # pylint: disable=too-many-statements
         self,
@@ -148,81 +155,117 @@ async def test_setting_power(  # pylint: disable=too-many-statements
         await self._init_pv_inverters(mocks)
         pv_pool = microgrid.new_pv_pool(priority=5)
         bounds_rx = pv_pool.power_status.new_receiver()
-        report = await self._recv_reports_until(
+        latest_report = await self._recv_reports_until(
             bounds_rx,
-            lambda x: x.bounds is not None and x.bounds.lower.as_watts() == -100_000.0,
+            lambda x: x.bounds is not None and x.bounds.lower.as_watts() == -100000.0,
         )
-        assert report is not None, "No report meeting the condition was received"
-        self._assert_report(report, power=None, lower=-100_000.0, upper=0.0)
-        await pv_pool.propose_power(Power.from_watts(-80_000.0))
-        report = await self._recv_reports_until(
+        dist_results_rx = pv_pool.power_distribution_results.new_receiver()
+
+        self._assert_report(latest_report, power=None, lower=-100000.0, upper=0.0)
+        await pv_pool.propose_power(Power.from_watts(-80000.0))
+        await self._recv_reports_until(
             bounds_rx,
             lambda x: x.target_power is not None
-            and x.target_power.as_watts() == -80_000.0,
+            and x.target_power.as_watts() == -80000.0,
+        )
+        self._assert_report(
+            await bounds_rx.receive(), power=-80000.0, lower=-100000.0, upper=0.0
         )
-        assert report is not None, "No report meeting the condition was received"
-        self._assert_report(report, power=-80_000.0, lower=-100_000.0, upper=0.0)
         await asyncio.sleep(0.0)
 
         # Components are set initial power
         assert set_power.call_count == 4
         inv_ids = mocks.microgrid.pv_inverter_ids
         assert sorted(set_power.call_args_list, key=lambda x: x.args[0]) == [
-            mocker.call(inv_ids[0], -10_000.0),
-            mocker.call(inv_ids[1], -20_000.0),
-            mocker.call(inv_ids[2], -25_000.0),
-            mocker.call(inv_ids[3], -25_000.0),
+            mocker.call(inv_ids[0], -10000.0),
+            mocker.call(inv_ids[1], -20000.0),
+            mocker.call(inv_ids[2], -25000.0),
+            mocker.call(inv_ids[3], -25000.0),
         ]
+        dist_results = await dist_results_rx.receive()
+        assert isinstance(
+            dist_results, _power_distributing.Success
+        ), f"Expected a success, got {dist_results}"
+        assert dist_results.succeeded_power == Power.from_watts(-80000.0)
+        assert dist_results.excess_power == Power.zero()
+        assert dist_results.succeeded_components == {
+            ComponentId(8),
+            ComponentId(18),
+            ComponentId(28),
+            ComponentId(38),
+        }
 
         set_power.reset_mock()
-        await pv_pool.propose_power(Power.from_watts(-4_000.0))
-        report = await self._recv_reports_until(
+        await pv_pool.propose_power(Power.from_watts(-4000.0))
+        await self._recv_reports_until(
             bounds_rx,
             lambda x: x.target_power is not None
-            and x.target_power.as_watts() == -4_000.0,
+            and x.target_power.as_watts() == -4000.0,
+        )
+        self._assert_report(
+            await bounds_rx.receive(), power=-4000.0, lower=-100000.0, upper=0.0
         )
-        assert report is not None, "No report meeting the condition was received"
-        self._assert_report(report, power=-4_000.0, lower=-100_000.0, upper=0.0)
         await asyncio.sleep(0.0)
 
         # Components are set initial power
         assert set_power.call_count == 4
         inv_ids = mocks.microgrid.pv_inverter_ids
         assert sorted(set_power.call_args_list, key=lambda x: x.args[0]) == [
-            mocker.call(inv_ids[0], -1_000.0),
-            mocker.call(inv_ids[1], -1_000.0),
-            mocker.call(inv_ids[2], -1_000.0),
-            mocker.call(inv_ids[3], -1_000.0),
+            mocker.call(inv_ids[0], -1000.0),
+            mocker.call(inv_ids[1], -1000.0),
+            mocker.call(inv_ids[2], -1000.0),
+            mocker.call(inv_ids[3], -1000.0),
         ]
+        dist_results = await dist_results_rx.receive()
+        assert isinstance(
+            dist_results, _power_distributing.Success
+        ), f"Expected a success, got {dist_results}"
+        assert dist_results.succeeded_power == Power.from_watts(-4000.0)
+        assert dist_results.excess_power == Power.zero()
+        assert dist_results.succeeded_components == {
+            ComponentId(8),
+            ComponentId(18),
+            ComponentId(28),
+            ComponentId(38),
+        }
 
         # After failing 1 inverter, bounds should go down and power shouldn't be
         # distributed to that inverter.
         print(f"\n[TEST] ========== FAILING INVERTER {inv_ids[1]} ==========")
         await self._fail_pv_inverters([inv_ids[1]], mocks)
         print("[TEST] Waiting for bounds to update to -80_000.0...")
-        report = await self._recv_reports_until(
+        await self._recv_reports_until(
             bounds_rx,
-            lambda x: x.bounds is not None and x.bounds.lower.as_watts() == -80_000.0,
+            lambda x: x.bounds is not None and x.bounds.lower.as_watts() == -80000.0,
+        )
+        self._assert_report(
+            await bounds_rx.receive(), power=-4000.0, lower=-80000.0, upper=0.0
         )
-        assert report is not None, "No report meeting the condition was received"
-        print(f"[TEST] Got bounds report: {report}")
-        self._assert_report(report, power=-4_000.0, lower=-80_000.0, upper=0.0)
+        dist_results = await dist_results_rx.receive()
+        assert isinstance(
+            dist_results, _power_distributing.Success
+        ), f"Expected a success, got {dist_results}"
+        assert dist_results.succeeded_power == Power.from_watts(-4000.0)
+        assert dist_results.excess_power == Power.zero()
+        assert dist_results.succeeded_components == {
+            ComponentId(8),
+            ComponentId(28),
+            ComponentId(38),
+        }
 
         set_power.reset_mock()
         print(f"\n[TEST] ========== PROPOSING NEW POWER -70_000.0 ==========")
-        print(f"[TEST] set_power call count before proposal: {set_power.call_count}")
-        await pv_pool.propose_power(Power.from_watts(-70_000.0))
+        await pv_pool.propose_power(Power.from_watts(-70000.0))
         print("[TEST] Waiting for target power to be -70_000.0...")
-        report = await self._recv_reports_until(
+        await self._recv_reports_until(
             bounds_rx,
             lambda x: x.target_power is not None
-            and x.target_power.as_watts() == -70_000.0,
+            and x.target_power.as_watts() == -70000.0,
         )
 
-        assert report is not None, "No report meeting the condition was received"
-        print(f"[TEST] Got target power report: {report}")
-        self._assert_report(report, power=-70_000.0, lower=-80_000.0, upper=0.0)
-        print(repr(report))
+        self._assert_report(
+            await bounds_rx.receive(), power=-70000.0, lower=-80000.0, upper=0.0
+        )
         await asyncio.sleep(0.0)
 
         # Components are set initial power
@@ -232,51 +275,89 @@ async def test_setting_power(  # pylint: disable=too-many-statements
         assert set_power.call_count == 3
         inv_ids = mocks.microgrid.pv_inverter_ids
         assert sorted(set_power.call_args_list, key=lambda x: x.args[0]) == [
-            mocker.call(inv_ids[0], -10_000.0),
-            mocker.call(inv_ids[2], -30_000.0),
-            mocker.call(inv_ids[3], -30_000.0),
+            mocker.call(inv_ids[0], -10000.0),
+            mocker.call(inv_ids[2], -30000.0),
+            mocker.call(inv_ids[3], -30000.0),
         ]
+        dist_results = await dist_results_rx.receive()
+        assert isinstance(
+            dist_results, _power_distributing.Success
+        ), f"Expected a success, got {dist_results}"
+        assert dist_results.succeeded_power == Power.from_watts(-70000.0)
+        assert dist_results.excess_power == Power.zero()
+        assert dist_results.succeeded_components == {
+            ComponentId(8),
+            ComponentId(28),
+            ComponentId(38),
+        }
 
         # After the failed inverter recovers, bounds should go back up and power
         # should be distributed to all inverters
         await self._fail_pv_inverters([], mocks)
-        report = await self._recv_reports_until(
+        await self._recv_reports_until(
             bounds_rx,
-            lambda x: x.bounds is not None and x.bounds.lower.as_watts() == -100_000.0,
+            lambda x: x.bounds is not None and x.bounds.lower.as_watts() == -100000.0,
+        )
+        self._assert_report(
+            await bounds_rx.receive(), power=-70000.0, lower=-100000.0, upper=0.0
         )
-        assert report is not None, "No report meeting the condition was received"
-        self._assert_report(report, power=-70_000.0, lower=-100_000.0, upper=0.0)
+        dist_results = await dist_results_rx.receive()
+        assert isinstance(
+            dist_results, _power_distributing.Success
+        ), f"Expected a success, got {dist_results}"
+        assert dist_results.succeeded_power == Power.from_watts(-70000.0)
+        assert dist_results.excess_power == Power.zero()
+        assert dist_results.succeeded_components == {
+            ComponentId(8),
+            ComponentId(18),
+            ComponentId(28),
+            ComponentId(38),
+        }
 
         set_power.reset_mock()
-        await pv_pool.propose_power(Power.from_watts(-90_000.0))
-        report = await self._recv_reports_until(
+        await pv_pool.propose_power(Power.from_watts(-200000.0))
+        await self._recv_reports_until(
             bounds_rx,
             lambda x: x.target_power is not None
-            and x.target_power.as_watts() == -90_000.0,
+            and x.target_power.as_watts() == -100000.0,
         )
 
-        assert report is not None, "No report meeting the condition was received"
-        self._assert_report(report, power=-90_000.0, lower=-100_000.0, upper=0.0)
+        self._assert_report(
+            await bounds_rx.receive(), power=-100000.0, lower=-100000.0, upper=0.0
+        )
         await asyncio.sleep(0.0)
 
         assert set_power.call_count == 4
         inv_ids = mocks.microgrid.pv_inverter_ids
         assert sorted(set_power.call_args_list, key=lambda x: x.args[0]) == [
-            mocker.call(inv_ids[0], -10_000.0),
-            mocker.call(inv_ids[1], -20_000.0),
-            mocker.call(inv_ids[2], -30_000.0),
-            mocker.call(inv_ids[3], -30_000.0),
+            mocker.call(inv_ids[0], -10000.0),
+            mocker.call(inv_ids[1], -20000.0),
+            mocker.call(inv_ids[2], -30000.0),
+            mocker.call(inv_ids[3], -40000.0),
         ]
+        dist_results = await dist_results_rx.receive()
+        assert isinstance(
+            dist_results, _power_distributing.Success
+        ), f"Expected a success, got {dist_results}"
+        assert dist_results.succeeded_power == Power.from_watts(-100000.0)
+        assert dist_results.excess_power == Power.zero()
+        assert dist_results.succeeded_components == {
+            ComponentId(8),
+            ComponentId(18),
+            ComponentId(28),
+            ComponentId(38),
+        }
 
         # Setting 0 power should set all inverters to 0
         set_power.reset_mock()
         await pv_pool.propose_power(Power.zero())
-        report = await self._recv_reports_until(
+        await self._recv_reports_until(
             bounds_rx,
             lambda x: x.target_power is not None and x.target_power.as_watts() == 0.0,
         )
-        assert report is not None, "No report meeting the condition was received"
-        self._assert_report(report, power=0.0, lower=-100_000.0, upper=0.0)
+        self._assert_report(
+            await bounds_rx.receive(), power=0.0, lower=-100000.0, upper=0.0
+        )
         await asyncio.sleep(0.0)
 
         assert set_power.call_count == 4
@@ -287,6 +368,18 @@ async def test_setting_power(  # pylint: disable=too-many-statements
             mocker.call(inv_ids[2], 0.0),
             mocker.call(inv_ids[3], 0.0),
         ]
+        dist_results = await dist_results_rx.receive()
+        assert isinstance(
+            dist_results, _power_distributing.Success
+        ), f"Expected a success, got {dist_results}"
+        assert dist_results.succeeded_power == Power.zero()
+        assert dist_results.excess_power == Power.zero()
+        assert dist_results.succeeded_components == {
+            ComponentId(8),
+            ComponentId(18),
+            ComponentId(28),
+            ComponentId(38),
+        }
 
         # Resetting the power should lead to default (full) power getting set for all
         # inverters.
@@ -307,3 +400,15 @@ async def test_setting_power(  # pylint: disable=too-many-statements
             mocker.call(inv_ids[2], -30_000.0),
             mocker.call(inv_ids[3], -40_000.0),
         ]
+        dist_results = await dist_results_rx.receive()
+        assert isinstance(
+            dist_results, _power_distributing.Success
+        ), f"Expected a success, got {dist_results}"
+        assert dist_results.succeeded_power == Power.from_watts(-100000.0)
+        assert dist_results.excess_power == Power.zero()
+        assert dist_results.succeeded_components == {
+            ComponentId(8),
+            ComponentId(18),
+            ComponentId(28),
+            ComponentId(38),
+        }