Remove producer and consumer from logical meter

The producer and consumer power formulas are now
implemented in their own logical component classes.

Signed-off-by: Daniel Zullo <[email protected]>

Author: daniel-zullo-frequenz

src/frequenz/sdk/timeseries/logical_meter/_logical_meter.py

@@ -13,12 +13,7 @@
 from .._quantities import Power, Quantity
 from ..formula_engine import FormulaEngine
 from ..formula_engine._formula_engine_pool import FormulaEnginePool
-from ..formula_engine._formula_generators import (
-    CHPPowerFormula,
-    ConsumerPowerFormula,
-    ProducerPowerFormula,
-    PVPowerFormula,
-)
+from ..formula_engine._formula_generators import CHPPowerFormula, PVPowerFormula
 
 
 class LogicalMeter:
@@ -50,9 +45,9 @@ class LogicalMeter:
         grid = microgrid.grid()
 
         # Get a receiver for a builtin formula
-        consumer_power_recv = logical_meter.consumer_power.new_receiver()
-        async for consumer_power_sample in consumer_power_recv:
-            print(consumer_power_sample)
+        pv_power_recv = logical_meter.pv_power.new_receiver()
+        async for pv_power_sample in pv_power_recv:
+            print(pv_power_sample)
 
         # or compose formulas to create a new formula
         net_power_recv = (
@@ -128,56 +123,6 @@ def start_formula(
             formula, component_metric_id, nones_are_zeros=nones_are_zeros
         )
 
-    @property
-    def consumer_power(self) -> FormulaEngine[Power]:
-        """Fetch the consumer power for the microgrid.
-
-        Under normal circumstances this is expected to correspond to the gross
-        consumption of the site excluding active parts and battery.
-
-        This formula produces values that are in the Passive Sign Convention (PSC).
-
-        If a formula engine to calculate consumer power is not already running, it will
-        be started.
-
-        A receiver from the formula engine can be created using the `new_receiver`
-        method.
-
-        Returns:
-            A FormulaEngine that will calculate and stream consumer power.
-        """
-        engine = self._formula_pool.from_power_formula_generator(
-            "consumer_power",
-            ConsumerPowerFormula,
-        )
-        assert isinstance(engine, FormulaEngine)
-        return engine
-
-    @property
-    def producer_power(self) -> FormulaEngine[Power]:
-        """Fetch the producer power for the microgrid.
-
-        Under normal circumstances this is expected to correspond to the production
-        of the sites active parts excluding ev chargers and batteries.
-
-        This formula produces values that are in the Passive Sign Convention (PSC).
-
-        If a formula engine to calculate producer power is not already running, it will
-        be started.
-
-        A receiver from the formula engine can be created using the `new_receiver`
-        method.
-
-        Returns:
-            A FormulaEngine that will calculate and stream producer power.
-        """
-        engine = self._formula_pool.from_power_formula_generator(
-            "producer_power",
-            ProducerPowerFormula,
-        )
-        assert isinstance(engine, FormulaEngine)
-        return engine
-
     @property
     def pv_power(self) -> FormulaEngine[Power]:
         """Fetch the PV power in the microgrid.

tests/timeseries/test_logical_meter.py

@@ -75,132 +75,3 @@ async def test_pv_power_no_pv_components(self, mocker: MockerFixture) -> None:
 
             await mockgrid.mock_resampler.send_non_existing_component_value()
             assert (await pv_power_receiver.receive()).value == Power.zero()
-
-    async def test_consumer_power_grid_meter(self, mocker: MockerFixture) -> None:
-        """Test the consumer power formula with a grid meter."""
-        mockgrid = MockMicrogrid(grid_meter=True, mocker=mocker)
-        mockgrid.add_batteries(2)
-        mockgrid.add_solar_inverters(2)
-
-        async with mockgrid, AsyncExitStack() as stack:
-            logical_meter = microgrid.logical_meter()
-            stack.push_async_callback(logical_meter.stop)
-            consumer_power_receiver = logical_meter.consumer_power.new_receiver()
-
-            await mockgrid.mock_resampler.send_meter_power([20.0, 2.0, 3.0, 4.0, 5.0])
-            assert (await consumer_power_receiver.receive()).value == Power.from_watts(
-                6.0
-            )
-
-    async def test_consumer_power_no_grid_meter(self, mocker: MockerFixture) -> None:
-        """Test the consumer power formula without a grid meter."""
-        mockgrid = MockMicrogrid(grid_meter=False, mocker=mocker)
-        mockgrid.add_consumer_meters()
-        mockgrid.add_batteries(2)
-        mockgrid.add_solar_inverters(2)
-
-        async with mockgrid, AsyncExitStack() as stack:
-            logical_meter = microgrid.logical_meter()
-            stack.push_async_callback(logical_meter.stop)
-            consumer_power_receiver = logical_meter.consumer_power.new_receiver()
-
-            await mockgrid.mock_resampler.send_meter_power([20.0, 2.0, 3.0, 4.0, 5.0])
-            assert (await consumer_power_receiver.receive()).value == Power.from_watts(
-                20.0
-            )
-
-    async def test_consumer_power_no_grid_meter_no_consumer_meter(
-        self, mocker: MockerFixture
-    ) -> None:
-        """Test the consumer power formula without a grid meter."""
-        mockgrid = MockMicrogrid(grid_meter=False, mocker=mocker)
-        mockgrid.add_batteries(2)
-        mockgrid.add_solar_inverters(2)
-
-        async with mockgrid, AsyncExitStack() as stack:
-            logical_meter = microgrid.logical_meter()
-            stack.push_async_callback(logical_meter.stop)
-            consumer_power_receiver = logical_meter.consumer_power.new_receiver()
-
-            await mockgrid.mock_resampler.send_non_existing_component_value()
-            assert (await consumer_power_receiver.receive()).value == Power.from_watts(
-                0.0
-            )
-
-    async def test_producer_power(self, mocker: MockerFixture) -> None:
-        """Test the producer power formula."""
-        mockgrid = MockMicrogrid(grid_meter=False, mocker=mocker)
-        mockgrid.add_solar_inverters(2)
-        mockgrid.add_chps(2)
-
-        async with mockgrid, AsyncExitStack() as stack:
-            logical_meter = microgrid.logical_meter()
-            stack.push_async_callback(logical_meter.stop)
-            producer_power_receiver = logical_meter.producer_power.new_receiver()
-
-            await mockgrid.mock_resampler.send_meter_power([2.0, 3.0, 4.0, 5.0])
-            assert (await producer_power_receiver.receive()).value == Power.from_watts(
-                14.0
-            )
-
-    async def test_producer_power_no_chp(self, mocker: MockerFixture) -> None:
-        """Test the producer power formula without a chp."""
-        mockgrid = MockMicrogrid(grid_meter=False, mocker=mocker)
-        mockgrid.add_solar_inverters(2)
-
-        async with mockgrid, AsyncExitStack() as stack:
-            logical_meter = microgrid.logical_meter()
-            stack.push_async_callback(logical_meter.stop)
-            producer_power_receiver = logical_meter.producer_power.new_receiver()
-
-            await mockgrid.mock_resampler.send_meter_power([2.0, 3.0])
-            assert (await producer_power_receiver.receive()).value == Power.from_watts(
-                5.0
-            )
-
-    async def test_producer_power_no_pv_no_consumer_meter(
-        self, mocker: MockerFixture
-    ) -> None:
-        """Test the producer power formula without pv and without consumer meter."""
-        mockgrid = MockMicrogrid(grid_meter=False, mocker=mocker)
-        mockgrid.add_chps(1, True)
-
-        async with mockgrid, AsyncExitStack() as stack:
-            logical_meter = microgrid.logical_meter()
-            stack.push_async_callback(logical_meter.stop)
-            producer_power_receiver = logical_meter.producer_power.new_receiver()
-
-            await mockgrid.mock_resampler.send_chp_power([2.0])
-            assert (await producer_power_receiver.receive()).value == Power.from_watts(
-                2.0
-            )
-
-    async def test_producer_power_no_pv(self, mocker: MockerFixture) -> None:
-        """Test the producer power formula without pv."""
-        mockgrid = MockMicrogrid(grid_meter=False, mocker=mocker)
-        mockgrid.add_consumer_meters()
-        mockgrid.add_chps(1)
-
-        async with mockgrid, AsyncExitStack() as stack:
-            logical_meter = microgrid.logical_meter()
-            stack.push_async_callback(logical_meter.stop)
-            producer_power_receiver = logical_meter.producer_power.new_receiver()
-
-            await mockgrid.mock_resampler.send_meter_power([20.0, 2.0])
-            assert (await producer_power_receiver.receive()).value == Power.from_watts(
-                2.0
-            )
-
-    async def test_no_producer_power(self, mocker: MockerFixture) -> None:
-        """Test the producer power formula without producers."""
-        async with MockMicrogrid(
-            grid_meter=True, mocker=mocker
-        ) as mockgrid, AsyncExitStack() as stack:
-            logical_meter = microgrid.logical_meter()
-            stack.push_async_callback(logical_meter.stop)
-            producer_power_receiver = logical_meter.producer_power.new_receiver()
-
-            await mockgrid.mock_resampler.send_non_existing_component_value()
-            assert (await producer_power_receiver.receive()).value == Power.from_watts(
-                0.0
-            )