Remove all remaining references to FormulaEngines

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

Author: shsms

docs/user-guide/formula-engine.md renamed to docs/user-guide/formulas.md

@@ -1,6 +1,6 @@
-# Formula Engine
+# Formulas
 
-::: frequenz.sdk.timeseries.formula_engine
+::: frequenz.sdk.timeseries.formulas
     options:
         members: None
         show_bases: false

src/frequenz/sdk/microgrid/__init__.py

@@ -153,7 +153,7 @@
 ## Streaming component data
 
 All pools have a `power` property, which is a
-[`FormulaEngine`][frequenz.sdk.timeseries.formula_engine.FormulaEngine] that can
+[`Formula`][frequenz.sdk.timeseries.formulas.Formula] that can
 
 - provide a stream of resampled power values, which correspond to the sum of the
 power measured from all the components in the pool together.

src/frequenz/sdk/timeseries/battery_pool/_battery_pool.py

@@ -4,8 +4,8 @@
 """An external interface for the BatteryPool.
 
 Allows for actors interested in operating on the same set of batteries to share
-underlying formula engine and metric calculator instances, but without having to specify
-their individual priorities with each request.
+underlying formula and metric calculator instances, but without having to
+specify their individual priorities with each request.
 """
 
 import asyncio
@@ -196,23 +196,22 @@ def power(self) -> Formula[Power]:
 
         This formula produces values that are in the Passive Sign Convention (PSC).
 
-        If a formula engine to calculate this metric is not already running, it will be
+        If a formula to calculate this metric is not already running, it will be
         started.
 
-        A receiver from the formula engine can be obtained by calling the `new_receiver`
+        A receiver from the formula can be obtained by calling the `new_receiver`
         method.
 
         Returns:
-            A FormulaEngine that will calculate and stream the total power of all
+            A Formula that will calculate and stream the total power of all
                 batteries in the pool.
         """
-        engine = self._pool_ref_store._formula_pool.from_power_formula(
+        return self._pool_ref_store._formula_pool.from_power_formula(
             "battery_pool_power",
             connection_manager.get().component_graph.battery_formula(
                 self._pool_ref_store._batteries
             ),
         )
-        return engine
 
     @property
     def soc(self) -> ReceiverFetcher[Sample[Percentage]]:

src/frequenz/sdk/timeseries/battery_pool/_battery_pool_reference_store.py

@@ -29,7 +29,7 @@ class BatteryPoolReferenceStore:  # pylint: disable=too-many-instance-attributes
     """A class for maintaining the shared state/tasks for a set of pool of batteries.
 
     This includes ownership of
-    - the formula engine pool and metric calculators.
+    - the formula pool and metric calculators.
     - the tasks for updating the battery status for the metric calculators.
 
     These are independent of the priority of the actors and can be shared between

src/frequenz/sdk/timeseries/consumer.py

@@ -53,7 +53,7 @@ class Consumer:
     """
 
     _formula_pool: FormulaPool
-    """The formula engine pool to generate consumer metrics."""
+    """The formula pool to generate consumer metrics."""
 
     def __init__(
         self,
@@ -79,20 +79,20 @@ def power(self) -> Formula[Power]:
 
         This formula produces values that are in the Passive Sign Convention (PSC).
 
-        It will start the formula engine to calculate consumer power if it is
+        It will start the formula to calculate consumer power if it is
         not already running.
 
-        A receiver from the formula engine can be created using the
+        A receiver from the formula can be created using the
         `new_receiver` method.
 
         Returns:
-            A FormulaEngine that will calculate and stream consumer power.
+            A Formula that will calculate and stream consumer power.
         """
         return self._formula_pool.from_power_formula(
             "consumer_power",
             connection_manager.get().component_graph.consumer_formula(),
         )
 
     async def stop(self) -> None:
-        """Stop all formula engines."""
+        """Stop all formulas."""
         await self._formula_pool.stop()

src/frequenz/sdk/timeseries/ev_charger_pool/_ev_charger_pool.py

@@ -119,14 +119,14 @@ def current_per_phase(self) -> Formula3Phase[Current]:
 
         This formula produces values that are in the Passive Sign Convention (PSC).
 
-        If a formula engine to calculate EV Charger current is not already running, it
+        If a formula to calculate EV Charger current is not already running, it
         will be started.
 
-        A receiver from the formula engine can be created using the `new_receiver`
+        A receiver from the formula can be created using the `new_receiver`
         method.
 
         Returns:
-            A FormulaEngine that will calculate and stream the total current of all EV
+            A Formula that will calculate and stream the total current of all EV
                 Chargers.
         """
         return self._pool_ref_store.formula_pool.from_current_3_phase_formula(
@@ -142,14 +142,14 @@ def power(self) -> Formula[Power]:
 
         This formula produces values that are in the Passive Sign Convention (PSC).
 
-        If a formula engine to calculate EV Charger power is not already running, it
+        If a formula to calculate EV Charger power is not already running, it
         will be started.
 
-        A receiver from the formula engine can be created using the `new_receiver`
+        A receiver from the formula can be created using the `new_receiver`
         method.
 
         Returns:
-            A FormulaEngine that will calculate and stream the total power of all EV
+            A Formula that will calculate and stream the total power of all EV
                 Chargers.
         """
         return self._pool_ref_store.formula_pool.from_power_formula(

src/frequenz/sdk/timeseries/ev_charger_pool/_ev_charger_pool_reference_store.py

@@ -25,7 +25,7 @@ class EVChargerPoolReferenceStore:
     """A class for maintaining the shared state/tasks for a set of pool of EV chargers.
 
     This includes ownership of
-    - the formula engine pool and metric calculators.
+    - the formula pool and metric calculators.
     - the tasks for calculating system bounds for the EV chargers.
 
     These are independent of the priority of the actors and can be shared between

src/frequenz/sdk/timeseries/formulas/_formula_pool.py

@@ -28,17 +28,17 @@
 """The component ID for non-existent components in the components graph.
 
 The non-existing component ID is commonly used in scenarios where a formula
-engine requires a component ID but there are no available components in the
-graph to associate with it. Thus, the non-existing component ID is subscribed
-instead so that the formula engine can send `None` or `0` values at the same
-frequency as the other streams.
+requires a component ID but there are no available components in the graph to
+associate with it. Thus, the non-existing component ID is subscribed instead so
+that the formula can send `None` or `0` values at the same frequency as the
+other streams.
 """
 
 
 class FormulaPool:
-    """Creates and owns formula engines from string formulas, or formula generators.
+    """Creates and owns formulas from string formulas.
 
-    If an engine already exists with a given name, it is reused instead.
+    If a formula already exists with a given name, it is reused instead.
     """
 
     def __init__(
@@ -62,13 +62,13 @@ def __init__(
             resampler_subscription_sender
         )
 
-        self._string_engines: dict[str, Formula[Quantity]] = {}
-        self._power_engines: dict[str, Formula[Power]] = {}
-        self._reactive_power_engines: dict[str, Formula[ReactivePower]] = {}
-        self._current_engines: dict[str, Formula3Phase[Current]] = {}
+        self._string_formulas: dict[str, Formula[Quantity]] = {}
+        self.power_formulas: dict[str, Formula[Power]] = {}
+        self._reactive_power_formulas: dict[str, Formula[ReactivePower]] = {}
+        self._current_formulas: dict[str, Formula3Phase[Current]] = {}
 
-        self._power_3_phase_engines: dict[str, Formula3Phase[Power]] = {}
-        self._current_3_phase_engines: dict[str, Formula3Phase[Current]] = {}
+        self._power_3_phase_formulas: dict[str, Formula3Phase[Power]] = {}
+        self._current_3_phase_formulas: dict[str, Formula3Phase[Current]] = {}
 
     def from_string(
         self,
@@ -83,18 +83,18 @@ def from_string(
                 actor.
 
         Returns:
-            A Formula engine that streams values with the formulas applied.
+            A Formula that streams values with the formulas applied.
         """
         channel_key = formula_str + str(metric.value)
-        if channel_key in self._string_engines:
-            return self._string_engines[channel_key]
+        if channel_key in self._string_formulas:
+            return self._string_formulas[channel_key]
         formula = parse(
             name=channel_key,
             formula=formula_str,
             telemetry_fetcher=self._telemetry_fetcher(metric),
             create_method=Quantity,
         )
-        self._string_engines[channel_key] = formula
+        self._string_formulas[channel_key] = formula
         return formula
 
     def from_power_formula(self, channel_key: str, formula_str: str) -> Formula[Power]:
@@ -106,10 +106,10 @@ def from_power_formula(self, channel_key: str, formula_str: str) -> Formula[Powe
             formula_str: The formula string.
 
         Returns:
-            A formula engine that evaluates the given formula.
+            A formula that evaluates the given formula.
         """
-        if channel_key in self._power_engines:
-            return self._power_engines[channel_key]
+        if channel_key in self.power_formulas:
+            return self.power_formulas[channel_key]
 
         if formula_str == "0.0":
             formula_str = f"coalesce(#{NON_EXISTING_COMPONENT_ID}, 0.0)"
@@ -120,7 +120,7 @@ def from_power_formula(self, channel_key: str, formula_str: str) -> Formula[Powe
             telemetry_fetcher=self._telemetry_fetcher(Metric.AC_POWER_ACTIVE),
             create_method=Power.from_watts,
         )
-        self._power_engines[channel_key] = formula
+        self.power_formulas[channel_key] = formula
 
         return formula
 
@@ -135,10 +135,10 @@ def from_reactive_power_formula(
             formula_str: The formula string.
 
         Returns:
-            A formula engine that evaluates the given formula.
+            A formula that evaluates the given formula.
         """
-        if channel_key in self._power_engines:
-            return self._reactive_power_engines[channel_key]
+        if channel_key in self.power_formulas:
+            return self._reactive_power_formulas[channel_key]
 
         if formula_str == "0.0":
             formula_str = f"coalesce(#{NON_EXISTING_COMPONENT_ID}, 0.0)"
@@ -149,7 +149,7 @@ def from_reactive_power_formula(
             telemetry_fetcher=self._telemetry_fetcher(Metric.AC_POWER_REACTIVE),
             create_method=ReactivePower.from_volt_amperes_reactive,
         )
-        self._reactive_power_engines[channel_key] = formula
+        self._reactive_power_formulas[channel_key] = formula
 
         return formula
 
@@ -164,10 +164,10 @@ def from_power_3_phase_formula(
             formula_str: The formula string.
 
         Returns:
-            A formula engine that evaluates the given formula.
+            A formula that evaluates the given formula.
         """
-        if channel_key in self._power_3_phase_engines:
-            return self._power_3_phase_engines[channel_key]
+        if channel_key in self._power_3_phase_formulas:
+            return self._power_3_phase_formulas[channel_key]
 
         if formula_str == "0.0":
             formula_str = f"coalesce(#{NON_EXISTING_COMPONENT_ID}, 0.0)"
@@ -199,7 +199,7 @@ def from_power_3_phase_formula(
                 create_method=Power.from_watts,
             ),
         )
-        self._power_3_phase_engines[channel_key] = formula
+        self._power_3_phase_formulas[channel_key] = formula
 
         return formula
 
@@ -214,10 +214,10 @@ def from_current_3_phase_formula(
             formula_str: The formula string.
 
         Returns:
-            A formula engine that evaluates the given formula.
+            A formula that evaluates the given formula.
         """
-        if channel_key in self._current_3_phase_engines:
-            return self._current_3_phase_engines[channel_key]
+        if channel_key in self._current_3_phase_formulas:
+            return self._current_3_phase_formulas[channel_key]
 
         if formula_str == "0.0":
             formula_str = f"coalesce(#{NON_EXISTING_COMPONENT_ID}, 0.0)"
@@ -243,27 +243,27 @@ def from_current_3_phase_formula(
                 create_method=Current.from_amperes,
             ),
         )
-        self._current_3_phase_engines[channel_key] = formula
+        self._current_3_phase_formulas[channel_key] = formula
 
         return formula
 
     async def stop(self) -> None:
-        """Stop all formula engines."""
-        for pf in self._power_engines.values():
+        """Stop all formulas."""
+        for pf in self.power_formulas.values():
             await pf.stop()
-        self._power_engines.clear()
+        self.power_formulas.clear()
 
-        for rpf in self._reactive_power_engines.values():
+        for rpf in self._reactive_power_formulas.values():
             await rpf.stop()
-        self._reactive_power_engines.clear()
+        self._reactive_power_formulas.clear()
 
-        for p3pf in self._power_3_phase_engines.values():
+        for p3pf in self._power_3_phase_formulas.values():
             await p3pf.stop()
-        self._power_3_phase_engines.clear()
+        self._power_3_phase_formulas.clear()
 
-        for c3pf in self._current_3_phase_engines.values():
+        for c3pf in self._current_3_phase_formulas.values():
             await c3pf.stop()
-        self._current_3_phase_engines.clear()
+        self._current_3_phase_formulas.clear()
 
     def _telemetry_fetcher(self, metric: Metric) -> ResampledStreamFetcher:
         """Create a ResampledStreamFetcher for the given metric.