openenergyid 0.1.18__py2.py3-none-any.whl → 0.1.20__py2.py3-none-any.whl

openenergyid/__init__.py

@@ -1,6 +1,6 @@
 """Open Energy ID Python SDK."""
 
-__version__ = "0.1.18"
+__version__ = "0.1.20"
 
 from .enums import Granularity
 from .models import TimeDataFrame, TimeSeries

openenergyid/dyntar/__init__.py

@@ -1,9 +1,10 @@
 """Dynamic Tariff Analysis module."""
 
-from .main import calculate_dyntar_columns
+from .main import calculate_dyntar_columns, summarize_result
 from .models import (
     DynamicTariffAnalysisInput,
     DynamicTariffAnalysisOutput,
+    DynamicTariffAnalysisOutputSummary,
     OutputColumns,
     RequiredColumns,
 )
@@ -12,6 +13,8 @@ __all__ = [
     "calculate_dyntar_columns",
     "DynamicTariffAnalysisInput",
     "DynamicTariffAnalysisOutput",
+    "DynamicTariffAnalysisOutputSummary",
     "OutputColumns",
     "RequiredColumns",
+    "summarize_result",
 ]

openenergyid/dyntar/const.py

@@ -1,5 +1,7 @@
 """Constants for the dyntar analysis."""
 
+from enum import Enum
+
 ELECTRICITY_DELIVERED_SMR3 = "electricity_delivered_smr3"
 ELECTRICITY_EXPORTED_SMR3 = "electricity_exported_smr3"
 ELECTRICITY_DELIVERED_SMR2 = "electricity_delivered_smr2"
@@ -20,3 +22,10 @@ HEATMAP_TOTAL = "heatmap_total"
 HEATMAP_DELIVERED_DESCRIPTION = "heatmap_delivered_description"
 HEATMAP_EXPORTED_DESCRIPTION = "heatmap_exported_description"
 HEATMAP_TOTAL_DESCRIPTION = "heatmap_total_description"
+
+
+class Register(Enum):
+    """Register for dynamic tariff analysis."""
+
+    DELIVERY = "delivery"
+    EXPORT = "export"

openenergyid/dyntar/main.py

@@ -1,6 +1,6 @@
 """Main module of the DynTar package."""
 
-import numpy as np
+from typing import cast
 import pandas as pd
 
 from openenergyid.const import (
@@ -29,33 +29,40 @@ from .const import (
     HEATMAP_DELIVERED_DESCRIPTION,
     HEATMAP_EXPORTED_DESCRIPTION,
     HEATMAP_TOTAL_DESCRIPTION,
+    Register,
 )
 
 
-def weigh_by_monthly_profile(series: pd.Series, profile: pd.Series) -> pd.Series:
+def weigh_by_monthly_profile(df: pd.DataFrame, series_name, profile_name) -> pd.Series:
     """Weigh a time series by a monthly profile."""
-    df = pd.DataFrame({"series": series, "profile": profile})
-    results = []
-    for _, frame in df.groupby(pd.Grouper(freq="MS")):
-        frame = frame.copy()
-        frame["weighted"] = frame["series"].sum() * (frame["profile"] / frame["profile"].sum())
-        results.append(frame)
-    return pd.concat(results)["weighted"]
+    grouped = df.groupby(pd.Grouper(freq="MS"))
+    return grouped[series_name].transform("sum") * grouped[profile_name].transform(
+        lambda x: x / x.sum()
+    )
 
 
-def extend_dataframe_with_smr2(df: pd.DataFrame, inplace: bool = False) -> pd.DataFrame | None:
+def extend_dataframe_with_smr2(
+    df: pd.DataFrame,
+    inplace: bool = False,
+    registers: list[Register] | None = None,
+) -> pd.DataFrame | None:
     """Extend a DataFrame with the SMR2 columns."""
     if not inplace:
         result_df = df.copy()
     else:
         result_df = df
 
-    result_df[ELECTRICITY_DELIVERED_SMR2] = weigh_by_monthly_profile(
-        df[ELECTRICITY_DELIVERED], df[RLP]
-    )
-    result_df[ELECTRICITY_EXPORTED_SMR2] = weigh_by_monthly_profile(
-        df[ELECTRICITY_EXPORTED], df[SPP]
-    )
+    if registers is None:
+        registers = [Register.DELIVERY, Register.EXPORT]
+
+    if Register.DELIVERY in registers:
+        result_df[ELECTRICITY_DELIVERED_SMR2] = weigh_by_monthly_profile(
+            df, ELECTRICITY_DELIVERED, RLP
+        )
+    if Register.EXPORT in registers:
+        result_df[ELECTRICITY_EXPORTED_SMR2] = weigh_by_monthly_profile(
+            df, ELECTRICITY_EXPORTED, SPP
+        )
 
     result_df.rename(
         columns={
@@ -63,6 +70,7 @@ def extend_dataframe_with_smr2(df: pd.DataFrame, inplace: bool = False) -> pd.Da
             ELECTRICITY_EXPORTED: ELECTRICITY_EXPORTED_SMR3,
         },
         inplace=True,
+        errors="ignore",
     )
 
     if not inplace:
@@ -70,26 +78,33 @@ def extend_dataframe_with_smr2(df: pd.DataFrame, inplace: bool = False) -> pd.Da
     return None
 
 
-def extend_dataframe_with_costs(df: pd.DataFrame, inplace: bool = False) -> pd.DataFrame | None:
+def extend_dataframe_with_costs(
+    df: pd.DataFrame, inplace: bool = False, registers: list[Register] | None = None
+) -> pd.DataFrame | None:
     """Extend a DataFrame with the cost columns."""
     if not inplace:
         result_df = df.copy()
     else:
         result_df = df
 
-    result_df[COST_ELECTRICITY_DELIVERED_SMR2] = (
-        df[ELECTRICITY_DELIVERED_SMR2] * df[PRICE_ELECTRICITY_DELIVERED]
-    )
-    result_df[COST_ELECTRICITY_EXPORTED_SMR2] = (
-        df[ELECTRICITY_EXPORTED_SMR2] * df[PRICE_ELECTRICITY_EXPORTED]
-    )
-
-    result_df[COST_ELECTRICITY_DELIVERED_SMR3] = (
-        df[ELECTRICITY_DELIVERED_SMR3] * df[PRICE_ELECTRICITY_DELIVERED]
-    )
-    result_df[COST_ELECTRICITY_EXPORTED_SMR3] = (
-        df[ELECTRICITY_EXPORTED_SMR3] * df[PRICE_ELECTRICITY_EXPORTED]
-    )
+    if registers is None:
+        registers = [Register.DELIVERY, Register.EXPORT]
+
+    if Register.DELIVERY in registers:
+        result_df[COST_ELECTRICITY_DELIVERED_SMR2] = (
+            df[ELECTRICITY_DELIVERED_SMR2] * df[PRICE_ELECTRICITY_DELIVERED]
+        )
+        result_df[COST_ELECTRICITY_DELIVERED_SMR3] = (
+            df[ELECTRICITY_DELIVERED_SMR3] * df[PRICE_ELECTRICITY_DELIVERED]
+        )
+
+    if Register.EXPORT in registers:
+        result_df[COST_ELECTRICITY_EXPORTED_SMR2] = (
+            df[ELECTRICITY_EXPORTED_SMR2] * df[PRICE_ELECTRICITY_EXPORTED] * -1
+        )
+        result_df[COST_ELECTRICITY_EXPORTED_SMR3] = (
+            df[ELECTRICITY_EXPORTED_SMR3] * df[PRICE_ELECTRICITY_EXPORTED] * -1
+        )
 
     if not inplace:
         return result_df
@@ -97,63 +112,70 @@ def extend_dataframe_with_costs(df: pd.DataFrame, inplace: bool = False) -> pd.D
 
 
 def extend_dataframe_with_weighted_prices(
-    df: pd.DataFrame, inplace: bool = False
+    df: pd.DataFrame, inplace: bool = False, registers: list[Register] | None = None
 ) -> pd.DataFrame | None:
     """Extend a DataFrame with the weighted price columns."""
     if not inplace:
         df = df.copy()
 
-    rlp_weighted_price_delivered = (df[PRICE_ELECTRICITY_DELIVERED] * df[RLP]).resample(
-        "MS"
-    ).sum() / df[RLP].resample("MS").sum()
-    df[RLP_WEIGHTED_PRICE_DELIVERED] = rlp_weighted_price_delivered.reindex_like(
-        df[RLP], method="ffill"
-    )
-    spp_weighted_price_exported = (df[PRICE_ELECTRICITY_EXPORTED] * df[SPP]).resample(
-        "MS"
-    ).sum() / df[SPP].resample("MS").sum()
-    df[SPP_WEIGHTED_PRICE_EXPORTED] = spp_weighted_price_exported.reindex_like(
-        df[SPP], method="ffill"
-    )
+    if registers is None:
+        registers = [Register.DELIVERY, Register.EXPORT]
+
+    if Register.DELIVERY in registers:
+        rlp_weighted_price_delivered = (df[PRICE_ELECTRICITY_DELIVERED] * df[RLP]).resample(
+            "MS"
+        ).sum() / df[RLP].resample("MS").sum()
+        df[RLP_WEIGHTED_PRICE_DELIVERED] = rlp_weighted_price_delivered.reindex_like(
+            df[RLP], method="ffill"
+        )
+
+    if Register.EXPORT in registers:
+        spp_weighted_price_exported = (df[PRICE_ELECTRICITY_EXPORTED] * df[SPP]).resample(
+            "MS"
+        ).sum() / df[SPP].resample("MS").sum()
+        df[SPP_WEIGHTED_PRICE_EXPORTED] = spp_weighted_price_exported.reindex_like(
+            df[SPP], method="ffill"
+        )
 
     if not inplace:
         return df
     return None
 
 
-def extend_dataframe_with_heatmap(df: pd.DataFrame, inplace: bool = False) -> pd.DataFrame | None:
+def extend_dataframe_with_heatmap(
+    df: pd.DataFrame, inplace: bool = False, registers: list[Register] | None = None
+) -> pd.DataFrame | None:
     """Extend a DataFrame with the heatmap columns."""
     if not inplace:
         df = df.copy()
 
-    normalized_energy_delta_delivered = (
-        df[ELECTRICITY_DELIVERED_SMR2] - df[ELECTRICITY_DELIVERED_SMR3]
-    ) / df[ELECTRICITY_DELIVERED_SMR2]
-    normalized_price_delta_delivered = (
-        df[RLP_WEIGHTED_PRICE_DELIVERED] - df[PRICE_ELECTRICITY_DELIVERED]
-    ) / df[RLP_WEIGHTED_PRICE_DELIVERED]
-    heatmap_score_delivered = normalized_energy_delta_delivered * normalized_price_delta_delivered
-
-    normalized_energy_delta_exported = (
-        df[ELECTRICITY_EXPORTED_SMR2] - df[ELECTRICITY_EXPORTED_SMR3]
-    ) / df[ELECTRICITY_EXPORTED_SMR2]
-    normalized_energy_delta_exported = normalized_energy_delta_exported.replace(
-        [np.inf, -np.inf], np.nan
-    )
-    normalized_price_delta_exported = (
-        df[SPP_WEIGHTED_PRICE_EXPORTED] - df[PRICE_ELECTRICITY_EXPORTED]
-    ) / df[SPP_WEIGHTED_PRICE_EXPORTED]
-    heatmap_score_exported = normalized_energy_delta_exported * normalized_price_delta_exported
-
-    heatmap_score_delivered.fillna(0, inplace=True)
-    heatmap_score_exported.fillna(0, inplace=True)
-
-    # Invert scores so that positive values indicate a positive impact
-    heatmap_score_delivered = -heatmap_score_delivered
-    heatmap_score_combined = heatmap_score_delivered + heatmap_score_exported
-
-    df[HEATMAP_DELIVERED] = heatmap_score_delivered
-    df[HEATMAP_EXPORTED] = heatmap_score_exported
+    if registers is None:
+        registers = [Register.DELIVERY, Register.EXPORT]
+
+    if Register.DELIVERY in registers:
+        energy_delta_delivered = df[ELECTRICITY_DELIVERED_SMR2] - df[ELECTRICITY_DELIVERED_SMR3]
+        price_delta_delivered = df[RLP_WEIGHTED_PRICE_DELIVERED] - df[PRICE_ELECTRICITY_DELIVERED]
+        heatmap_score_delivered = energy_delta_delivered * price_delta_delivered
+        heatmap_score_delivered.fillna(0, inplace=True)
+        # Invert score so that positive values indicate a positive impact
+        heatmap_score_delivered = -heatmap_score_delivered
+        df[HEATMAP_DELIVERED] = heatmap_score_delivered
+
+    if Register.EXPORT in registers:
+        energy_delta_exported = df[ELECTRICITY_EXPORTED_SMR2] - df[ELECTRICITY_EXPORTED_SMR3]
+        price_delta_exported = df[SPP_WEIGHTED_PRICE_EXPORTED] - df[PRICE_ELECTRICITY_EXPORTED]
+        heatmap_score_exported = energy_delta_exported * price_delta_exported
+        heatmap_score_exported.fillna(0, inplace=True)
+        df[HEATMAP_EXPORTED] = heatmap_score_exported
+
+    if Register.DELIVERY in registers and Register.EXPORT in registers:
+        heatmap_score_delivered = cast(pd.Series, df[HEATMAP_DELIVERED])
+        heatmap_score_exported = cast(pd.Series, df[HEATMAP_EXPORTED])
+        heatmap_score_combined = heatmap_score_delivered + heatmap_score_exported
+    elif Register.DELIVERY in registers:
+        heatmap_score_combined = heatmap_score_delivered
+    else:
+        heatmap_score_combined = heatmap_score_exported
     df[HEATMAP_TOTAL] = heatmap_score_combined
 
     if not inplace:
@@ -161,127 +183,130 @@ def extend_dataframe_with_heatmap(df: pd.DataFrame, inplace: bool = False) -> pd
     return None
 
 
+def map_delivery_description(
+    price_delivered, price_rlp, electricity_delivered_smr3, electricity_delivered_smr2
+):
+    """Map the delivery description."""
+    if price_delivered > price_rlp and electricity_delivered_smr3 > electricity_delivered_smr2:
+        return 1
+    if price_delivered > price_rlp and electricity_delivered_smr3 < electricity_delivered_smr2:
+        return 2
+    if price_delivered < price_rlp and electricity_delivered_smr3 > electricity_delivered_smr2:
+        return 3
+    if price_delivered < price_rlp and electricity_delivered_smr3 < electricity_delivered_smr2:
+        return 4
+    return 0
+
+
+def map_export_description(
+    price_exported, price_spp, electricity_exported_smr3, electricity_exported_smr2
+):
+    """Map the export description."""
+    if price_exported > price_spp and electricity_exported_smr3 > electricity_exported_smr2:
+        return 5
+    if price_exported > price_spp and electricity_exported_smr3 < electricity_exported_smr2:
+        return 6
+    if price_exported < price_spp and electricity_exported_smr3 > electricity_exported_smr2:
+        return 7
+    if price_exported < price_spp and electricity_exported_smr3 < electricity_exported_smr2:
+        return 8
+    return 0
+
+
+def map_total_description(
+    abs_heatmap_delivered, abs_heatmap_exported, delivered_description, exported_description
+):
+    """Map the total description."""
+    if abs_heatmap_delivered > abs_heatmap_exported:
+        return delivered_description
+    return exported_description
+
+
 def extend_dataframe_with_heatmap_description(
-    df: pd.DataFrame, inplace: bool = False
+    df: pd.DataFrame, inplace: bool = False, registers: list[Register] | None = None
 ) -> pd.DataFrame | None:
     """Extend a DataFrame with the heatmap description columns."""
     if not inplace:
         df = df.copy()
 
-    # Delivered
-
-    # Where Heatmap is 0, we put a desription of 0 (No impact)
-    df[HEATMAP_DELIVERED_DESCRIPTION] = df[HEATMAP_DELIVERED].apply(
-        lambda x: 0 if x == 0 else float("NaN")
-    )
-    # When the energy delta is positive, and the price delta is positive, we put a description of 1 (high consumption, high price)
-    df[HEATMAP_DELIVERED_DESCRIPTION] = df.apply(
-        lambda x: 1
-        if x[PRICE_ELECTRICITY_DELIVERED] > x[RLP_WEIGHTED_PRICE_DELIVERED]
-        and x[ELECTRICITY_DELIVERED_SMR3] > x[ELECTRICITY_DELIVERED_SMR2]
-        else x[HEATMAP_DELIVERED_DESCRIPTION],
-        axis=1,
-    )
-    # When the energy delta is negative, and the price delta is positive, we put a description of 2 (low consumption, high price)
-    df[HEATMAP_DELIVERED_DESCRIPTION] = df.apply(
-        lambda x: 2
-        if x[PRICE_ELECTRICITY_DELIVERED] > x[RLP_WEIGHTED_PRICE_DELIVERED]
-        and x[ELECTRICITY_DELIVERED_SMR3] < x[ELECTRICITY_DELIVERED_SMR2]
-        else x[HEATMAP_DELIVERED_DESCRIPTION],
-        axis=1,
-    )
-    # When the energy delta is positive, and the price delta is negative, we put a description of 3 (high consumption, low price)
-    df[HEATMAP_DELIVERED_DESCRIPTION] = df.apply(
-        lambda x: 3
-        if x[PRICE_ELECTRICITY_DELIVERED] < x[RLP_WEIGHTED_PRICE_DELIVERED]
-        and x[ELECTRICITY_DELIVERED_SMR3] > x[ELECTRICITY_DELIVERED_SMR2]
-        else x[HEATMAP_DELIVERED_DESCRIPTION],
-        axis=1,
-    )
-    # When the energy delta is negative, and the price delta is negative, we put a description of 4 (low consumption, low price)
-    df[HEATMAP_DELIVERED_DESCRIPTION] = df.apply(
-        lambda x: 4
-        if x[PRICE_ELECTRICITY_DELIVERED] < x[RLP_WEIGHTED_PRICE_DELIVERED]
-        and x[ELECTRICITY_DELIVERED_SMR3] < x[ELECTRICITY_DELIVERED_SMR2]
-        else x[HEATMAP_DELIVERED_DESCRIPTION],
-        axis=1,
-    )
-    # All other cases are put as 0
-    df[HEATMAP_DELIVERED_DESCRIPTION] = df[HEATMAP_DELIVERED_DESCRIPTION].replace(np.nan, 0)
-
-    # Exported
-
-    # Where Heatmap is 0, we put a desription of 0 (No impact)
-    df[HEATMAP_EXPORTED_DESCRIPTION] = df[HEATMAP_EXPORTED].apply(
-        lambda x: 0 if x == 0 else float("NaN")
-    )
-    # When the energy delta is positive, and the price delta is positive, we put a description of 5 (high injection, high price)
-    df[HEATMAP_EXPORTED_DESCRIPTION] = df.apply(
-        lambda x: 5
-        if x[PRICE_ELECTRICITY_EXPORTED] > x[SPP_WEIGHTED_PRICE_EXPORTED]
-        and x[ELECTRICITY_EXPORTED_SMR3] > x[ELECTRICITY_EXPORTED_SMR2]
-        else x[HEATMAP_EXPORTED_DESCRIPTION],
-        axis=1,
-    )
-    # When the energy delta is negative, and the price delta is positive, we put a description of 6 (low injection, high price)
-    df[HEATMAP_EXPORTED_DESCRIPTION] = df.apply(
-        lambda x: 6
-        if x[PRICE_ELECTRICITY_EXPORTED] > x[SPP_WEIGHTED_PRICE_EXPORTED]
-        and x[ELECTRICITY_EXPORTED_SMR3] < x[ELECTRICITY_EXPORTED_SMR2]
-        else x[HEATMAP_EXPORTED_DESCRIPTION],
-        axis=1,
-    )
-    # When the energy delta is positive, and the price delta is negative, we put a description of 7 (high injection, low price)
-    df[HEATMAP_EXPORTED_DESCRIPTION] = df.apply(
-        lambda x: 7
-        if x[PRICE_ELECTRICITY_EXPORTED] < x[SPP_WEIGHTED_PRICE_EXPORTED]
-        and x[ELECTRICITY_EXPORTED_SMR3] > x[ELECTRICITY_EXPORTED_SMR2]
-        else x[HEATMAP_EXPORTED_DESCRIPTION],
-        axis=1,
-    )
-    # When the energy delta is negative, and the price delta is negative, we put a description of 8 (low injection, low price)
-    df[HEATMAP_EXPORTED_DESCRIPTION] = df.apply(
-        lambda x: 8
-        if x[PRICE_ELECTRICITY_EXPORTED] < x[SPP_WEIGHTED_PRICE_EXPORTED]
-        and x[ELECTRICITY_EXPORTED_SMR3] < x[ELECTRICITY_EXPORTED_SMR2]
-        else x[HEATMAP_EXPORTED_DESCRIPTION],
-        axis=1,
-    )
-    # All other cases are put as 0
-    df[HEATMAP_EXPORTED_DESCRIPTION] = df[HEATMAP_EXPORTED_DESCRIPTION].replace(np.nan, 0)
-
-    # Total
-
-    # We see which of the individual heatmaps has the highest absolute value
-    # We put the description of the highest absolute value
-    df[HEATMAP_TOTAL_DESCRIPTION] = df.apply(
-        lambda x: x[HEATMAP_DELIVERED_DESCRIPTION]
-        if abs(x[HEATMAP_DELIVERED]) > abs(x[HEATMAP_EXPORTED])
-        else x[HEATMAP_EXPORTED_DESCRIPTION],
-        axis=1,
-    )
-    # Where Heatmap is 0, we put a desription of 0 (No impact)
-    df[HEATMAP_TOTAL_DESCRIPTION] = df.apply(
-        lambda x: 0 if x[HEATMAP_TOTAL] == 0 else x[HEATMAP_TOTAL_DESCRIPTION], axis=1
-    )
-    # All other cases are put as 0
-    df[HEATMAP_TOTAL_DESCRIPTION] = df[HEATMAP_TOTAL_DESCRIPTION].replace(np.nan, 0)
+    if registers is None:
+        registers = [Register.DELIVERY, Register.EXPORT]
+
+    if Register.DELIVERY in registers:
+        df[HEATMAP_DELIVERED_DESCRIPTION] = list(
+            map(
+                map_delivery_description,
+                df[PRICE_ELECTRICITY_DELIVERED],
+                df[RLP_WEIGHTED_PRICE_DELIVERED],
+                df[ELECTRICITY_DELIVERED_SMR3],
+                df[ELECTRICITY_DELIVERED_SMR2],
+            )
+        )
+
+    if Register.EXPORT in registers:
+        df[HEATMAP_EXPORTED_DESCRIPTION] = list(
+            map(
+                map_export_description,
+                df[PRICE_ELECTRICITY_EXPORTED],
+                df[SPP_WEIGHTED_PRICE_EXPORTED],
+                df[ELECTRICITY_EXPORTED_SMR3],
+                df[ELECTRICITY_EXPORTED_SMR2],
+            )
+        )
+
+    if Register.DELIVERY in registers and Register.EXPORT in registers:
+        df[HEATMAP_TOTAL_DESCRIPTION] = list(
+            map(
+                map_total_description,
+                df[HEATMAP_DELIVERED].abs(),
+                df[HEATMAP_EXPORTED].abs(),
+                df[HEATMAP_DELIVERED_DESCRIPTION],
+                df[HEATMAP_EXPORTED_DESCRIPTION],
+            )
+        )
+    elif Register.DELIVERY in registers:
+        df[HEATMAP_TOTAL_DESCRIPTION] = df[HEATMAP_DELIVERED_DESCRIPTION]
+    else:
+        df[HEATMAP_TOTAL_DESCRIPTION] = df[HEATMAP_EXPORTED_DESCRIPTION]
 
     if not inplace:
         return df
 
 
-def calculate_dyntar_columns(df: pd.DataFrame, inplace: bool = False) -> pd.DataFrame | None:
+def calculate_dyntar_columns(
+    df: pd.DataFrame,
+    inplace: bool = False,
+    registers: list[Register] | None = None,
+) -> pd.DataFrame | None:
     """Calculate all columns required for the dynamic tariff analysis."""
     if not inplace:
         df = df.copy()
 
-    extend_dataframe_with_smr2(df, inplace=True)
-    extend_dataframe_with_costs(df, inplace=True)
-    extend_dataframe_with_weighted_prices(df, inplace=True)
-    extend_dataframe_with_heatmap(df, inplace=True)
-    extend_dataframe_with_heatmap_description(df, inplace=True)
+    if registers is None:
+        registers = [Register.DELIVERY, Register.EXPORT]
+
+    extend_dataframe_with_smr2(df, inplace=True, registers=registers)
+    extend_dataframe_with_costs(df, inplace=True, registers=registers)
+    extend_dataframe_with_weighted_prices(df, inplace=True, registers=registers)
+    extend_dataframe_with_heatmap(df, inplace=True, registers=registers)
+    extend_dataframe_with_heatmap_description(df, inplace=True, registers=registers)
 
     if not inplace:
         return df
     return None
+
+
+def summarize_result(df: pd.DataFrame) -> pd.Series:
+    """Summarize the dynamic tariff analysis result."""
+    summary = df.filter(like="cost").sum()
+
+    abs_smr2 = summary.filter(like="smr2").abs().sum()
+
+    summary["cost_electricity_total_smr2"] = summary.filter(like="smr2").sum()
+    summary["cost_electricity_total_smr3"] = summary.filter(like="smr3").sum()
+
+    summary["ratio"] = (
+        summary["cost_electricity_total_smr3"] - summary["cost_electricity_total_smr2"]
+    ) / abs_smr2
+
+    return summary

openenergyid/dyntar/models.py

@@ -1,9 +1,10 @@
 """Models for dynamic tariff analysis."""
 
 from typing import Literal
-from pydantic import Field, conlist, confloat
+from pydantic import Field, conlist, confloat, BaseModel
 
 from openenergyid.models import TimeDataFrame
+from .const import Register
 
 
 RequiredColumns = Literal[
@@ -43,18 +44,53 @@ class DynamicTariffAnalysisInput(TimeDataFrame):
     """Input frame for dynamic tariff analysis."""
 
     columns: list[RequiredColumns] = Field(
-        min_length=len(RequiredColumns.__args__),
+        min_length=3,
         max_length=len(RequiredColumns.__args__),
         examples=[RequiredColumns.__args__],
     )
     data: list[
         conlist(
             item_type=confloat(allow_inf_nan=True),
-            min_length=len(RequiredColumns.__args__),
+            min_length=3,
             max_length=len(RequiredColumns.__args__),
         )  # type: ignore
     ] = Field(examples=[[0.0] * len(RequiredColumns.__args__)])
 
+    @property
+    def registers(self) -> list[Register]:
+        """Check which registers are present in the input data."""
+        registers = []
+        columns = list(self.columns)
+        # if "electricity_delivered", "price_electricity_delivered" and "RLP" are present
+        if all(
+            column in columns
+            for column in [
+                "electricity_delivered",
+                "price_electricity_delivered",
+                "RLP",
+            ]
+        ):
+            registers.append(Register.DELIVERY)
+        # if "electricity_exported", "price_electricity_exported" and "SPP" are present
+        if all(
+            column in columns
+            for column in ["electricity_exported", "price_electricity_exported", "SPP"]
+        ):
+            registers.append(Register.EXPORT)
+        return registers
+
+
+class DynamicTariffAnalysisOutputSummary(BaseModel):
+    """Summary of the dynamic tariff analysis output."""
+
+    cost_electricity_delivered_smr2: float | None = None
+    cost_electricity_delivered_smr3: float | None = None
+    cost_electricity_exported_smr2: float | None = None
+    cost_electricity_exported_smr3: float | None = None
+    cost_electricity_total_smr2: float | None = None
+    cost_electricity_total_smr3: float | None = None
+    ratio: float | None = None
+
 
 class DynamicTariffAnalysisOutput(TimeDataFrame):
     """Output frame for dynamic tariff analysis."""
@@ -71,3 +107,4 @@ class DynamicTariffAnalysisOutput(TimeDataFrame):
             max_length=len(OutputColumns.__args__),
         )  # type: ignore
     ] = Field(examples=[[0.0] * len(OutputColumns.__args__)])
+    summary: DynamicTariffAnalysisOutputSummary | None = None

{openenergyid-0.1.18.dist-info → openenergyid-0.1.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openenergyid
-Version: 0.1.18
+Version: 0.1.20
 Summary: Open Source Python library for energy analytics and simulations
 Project-URL: Homepage, https://energyid.eu
 Project-URL: Repository, https://github.com/EnergieID/OpenEnergyID

{openenergyid-0.1.18.dist-info → openenergyid-0.1.20.dist-info}/RECORD

@@ -1,14 +1,14 @@
-openenergyid/__init__.py,sha256=ntL_zbXBUmsAcqrx7QRz8_g3CNWyjWhlg9osouG9a-k,193
+openenergyid/__init__.py,sha256=XVOYN9RAdcNJV1DaB0k2pD_zyPnk2aF6D5Tk4HFt4TU,193
 openenergyid/const.py,sha256=D-xUnUyVuLmphClkePgxpFP6z0RDhw_6m7rX0BHBgrw,823
 openenergyid/enums.py,sha256=jdw4CB1gkisx0re_SesrTEyh_T-UxYp6uieE7iYlHdA,357
 openenergyid/models.py,sha256=CO6VdthCOQ9hNXqVSan_4IOBpiQvOix-ea3U6TR7Vgc,4343
 openenergyid/capacity/__init__.py,sha256=1En96HlPV8kd1hOJO9RjRbXNInp5ZSkmjsjp0jfZlcQ,221
 openenergyid/capacity/main.py,sha256=G6_EtXs1k_W-fxS33pFrCNKajuH81skdI32zp5RX9bI,3674
 openenergyid/capacity/models.py,sha256=qi0IFyF_QOVleSzN8g0U2Fzqcc9ZDfNKt8oteFLY6Q0,832
-openenergyid/dyntar/__init__.py,sha256=iQXQXrEQOiVNeeF6LRmUf3oOhKlGjMNF7o4T04IWTGA,371
-openenergyid/dyntar/const.py,sha256=17qL0-S0SImsqrDEDrGS2GLyJYcJRw6GmmcTiML7tR0,956
-openenergyid/dyntar/main.py,sha256=z_F520eCsLcSYTo9e0iJBGpzoMo1G_TEECVCNi5rA_M,10732
-openenergyid/dyntar/models.py,sha256=FZq7HI1F-3nVeHwPkuB38-8u32JzdvsZaCzrhirFD2g,2094
+openenergyid/dyntar/__init__.py,sha256=lUrk7ktS7yAqiafRHFoBE0RvFSI9mzDoO37diwLHuBg,495
+openenergyid/dyntar/const.py,sha256=eJJV9VfpHlS9vWV47DWQkS3ICIXWhDmG4cU-ofbZJ3Q,1100
+openenergyid/dyntar/main.py,sha256=i8EkayRicnMhG66cyrxGwUumFx3UGe7KDSImfFqmK04,10638
+openenergyid/dyntar/models.py,sha256=lI4IjdAFallhsCqbw-EbBPbmk0g2MACgZnmMtTX7Pq0,3452
 openenergyid/energysharing/__init__.py,sha256=A4JfrUYf-hBCzhUm0qL1GGlNMvpO8OwXJo80dJxFIvw,274
 openenergyid/energysharing/const.py,sha256=X2zEPtTlsmZ66w6RmLS_h8NmdzObAEi5N6-0yrLN5V4,219
 openenergyid/energysharing/data_formatting.py,sha256=Kwuhyn6ao_8Brdm9frlA6VzYOqimNYZsRbYwNXnE7yc,2583
@@ -19,7 +19,7 @@ openenergyid/mvlr/helpers.py,sha256=Uzbfrj3IpH26wA206KOl0hNucKE-n9guJNC_EROBVKA,
 openenergyid/mvlr/main.py,sha256=cn7jZ98cHn2eh-0zG9q8Pad0Ft_FuI-u3a-eeHeF8jA,1304
 openenergyid/mvlr/models.py,sha256=XvkViOLlYqi0ffgF3AD4Jvk3yL05gsoKdKgBAsGJ7L4,8581
 openenergyid/mvlr/mvlr.py,sha256=F7WvWnZQtqUmK1vsguemsn9n8pDDk3tQ1weOlv-bo0c,18626
-openenergyid-0.1.18.dist-info/METADATA,sha256=d5UuJ8gqzwzSFx7aokbArsVr7RqetZoL8fJ3TwRuGlc,2477
-openenergyid-0.1.18.dist-info/WHEEL,sha256=fl6v0VwpzfGBVsGtkAkhILUlJxROXbA3HvRL6Fe3140,105
-openenergyid-0.1.18.dist-info/licenses/LICENSE,sha256=NgRdcNHwyXVCXZ8sJwoTp0DCowThJ9LWWl4xhbV1IUY,1074
-openenergyid-0.1.18.dist-info/RECORD,,
+openenergyid-0.1.20.dist-info/METADATA,sha256=UJ-vbPX22VRhTyEtFnf0XzxrQa-U2LbdocBPcUFucuo,2477
+openenergyid-0.1.20.dist-info/WHEEL,sha256=fl6v0VwpzfGBVsGtkAkhILUlJxROXbA3HvRL6Fe3140,105
+openenergyid-0.1.20.dist-info/licenses/LICENSE,sha256=NgRdcNHwyXVCXZ8sJwoTp0DCowThJ9LWWl4xhbV1IUY,1074
+openenergyid-0.1.20.dist-info/RECORD,,