openenergyid 0.1.9__py2.py3-none-any.whl → 0.1.12__py2.py3-none-any.whl

openenergyid/__init__.py

@@ -1,8 +1,8 @@
 """Open Energy ID Python SDK."""
 
-__version__ = "0.1.9"
+__version__ = "0.1.12"
 
 from .enums import Granularity
-from .models import TimeSeries
+from .models import TimeDataFrame, TimeSeries
 
-__all__ = ["Granularity", "TimeSeries"]
+__all__ = ["Granularity", "TimeDataFrame", "TimeSeries"]

openenergyid/const.py

@@ -11,3 +11,8 @@ ELECTRICITY_PRODUCED: Literal["electricity_produced"] = "electricity_produced"
 PRICE_DAY_AHEAD: Literal["price_day_ahead"] = "price_day_ahead"
 PRICE_IMBALANCE_UPWARD: Literal["price_imbalance_upward"] = "price_imbalance_upward"
 PRICE_IMBALANCE_DOWNWARD: Literal["price_imbalance_downward"] = "price_imbalance_downward"
+PRICE_ELECTRICITY_DELIVERED: Literal["price_electricity_delivered"] = "price_electricity_delivered"
+PRICE_ELECTRICITY_EXPORTED: Literal["price_electricity_exported"] = "price_electricity_exported"
+
+RLP: Literal["RLP"] = "RLP"
+SPP: Literal["SPP"] = "SPP"

openenergyid/dyntar/__init__.py

@@ -0,0 +1,17 @@
+"""Dynamic Tariff Analysis module."""
+
+from .main import calculate_dyntar_columns
+from .models import (
+    DynamicTariffAnalysisInput,
+    DynamicTariffAnalysisOutput,
+    OutputColumns,
+    RequiredColumns,
+)
+
+__all__ = [
+    "calculate_dyntar_columns",
+    "DynamicTariffAnalysisInput",
+    "DynamicTariffAnalysisOutput",
+    "OutputColumns",
+    "RequiredColumns",
+]

openenergyid/dyntar/const.py

@@ -0,0 +1,18 @@
+"""Constants for the dyntar analysis."""
+
+ELECTRICITY_DELIVERED_SMR3 = "electricity_delivered_smr3"
+ELECTRICITY_EXPORTED_SMR3 = "electricity_exported_smr3"
+ELECTRICITY_DELIVERED_SMR2 = "electricity_delivered_smr2"
+ELECTRICITY_EXPORTED_SMR2 = "electricity_exported_smr2"
+
+COST_ELECTRICITY_DELIVERED_SMR2 = "cost_electricity_delivered_smr2"
+COST_ELECTRICITY_EXPORTED_SMR2 = "cost_electricity_exported_smr2"
+COST_ELECTRICITY_DELIVERED_SMR3 = "cost_electricity_delivered_smr3"
+COST_ELECTRICITY_EXPORTED_SMR3 = "cost_electricity_exported_smr3"
+
+RLP_WEIGHTED_PRICE_DELIVERED = "rlp_weighted_price_delivered"
+SPP_WEIGHTED_PRICE_EXPORTED = "spp_weighted_price_exported"
+
+HEATMAP_DELIVERED = "heatmap_delivered"
+HEATMAP_EXPORTED = "heatmap_exported"
+HEATMAP_TOTAL = "heatmap_total"

openenergyid/dyntar/main.py

@@ -0,0 +1,169 @@
+"""Main module of the DynTar package."""
+
+from typing import Optional
+import pandas as pd
+
+from openenergyid.const import (
+    ELECTRICITY_DELIVERED,
+    ELECTRICITY_EXPORTED,
+    PRICE_ELECTRICITY_DELIVERED,
+    PRICE_ELECTRICITY_EXPORTED,
+    RLP,
+    SPP,
+)
+
+from .const import (
+    ELECTRICITY_DELIVERED_SMR3,
+    ELECTRICITY_EXPORTED_SMR3,
+    ELECTRICITY_DELIVERED_SMR2,
+    ELECTRICITY_EXPORTED_SMR2,
+    COST_ELECTRICITY_DELIVERED_SMR2,
+    COST_ELECTRICITY_EXPORTED_SMR2,
+    COST_ELECTRICITY_DELIVERED_SMR3,
+    COST_ELECTRICITY_EXPORTED_SMR3,
+    RLP_WEIGHTED_PRICE_DELIVERED,
+    SPP_WEIGHTED_PRICE_EXPORTED,
+    HEATMAP_DELIVERED,
+    HEATMAP_EXPORTED,
+    HEATMAP_TOTAL,
+)
+
+
+def weigh_by_monthly_profile(series: pd.Series, profile: pd.Series) -> 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"]
+
+
+def extend_dataframe_with_smr2(df: pd.DataFrame, inplace: bool = False) -> Optional[pd.DataFrame]:
+    """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]
+    )
+
+    result_df.rename(
+        columns={
+            ELECTRICITY_DELIVERED: ELECTRICITY_DELIVERED_SMR3,
+            ELECTRICITY_EXPORTED: ELECTRICITY_EXPORTED_SMR3,
+        },
+        inplace=True,
+    )
+
+    if not inplace:
+        return result_df
+    return None
+
+
+def extend_dataframe_with_costs(df: pd.DataFrame, inplace: bool = False) -> Optional[pd.DataFrame]:
+    """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 not inplace:
+        return result_df
+    return None
+
+
+def extend_dataframe_with_weighted_prices(
+    df: pd.DataFrame, inplace: bool = False
+) -> Optional[pd.DataFrame]:
+    """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 not inplace:
+        return df
+    return None
+
+
+def extend_dataframe_with_heatmap(
+    df: pd.DataFrame, inplace: bool = False
+) -> Optional[pd.DataFrame]:
+    """Extend a DataFrame with the heatmap columns."""
+    if not inplace:
+        df = df.copy()
+
+    heatmap_score_delivered = (
+        (df[ELECTRICITY_DELIVERED_SMR2] - df[ELECTRICITY_DELIVERED_SMR3])
+        / df[ELECTRICITY_DELIVERED_SMR2]
+        * (df[RLP_WEIGHTED_PRICE_DELIVERED] - df[PRICE_ELECTRICITY_DELIVERED])
+        / df[RLP_WEIGHTED_PRICE_DELIVERED]
+    )
+    heatmap_score_exported = (
+        (df[ELECTRICITY_EXPORTED_SMR2] - df[ELECTRICITY_EXPORTED_SMR3])
+        / df[ELECTRICITY_EXPORTED_SMR2]
+        * (df[SPP_WEIGHTED_PRICE_EXPORTED] - df[PRICE_ELECTRICITY_EXPORTED])
+        / df[SPP_WEIGHTED_PRICE_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_exported = -heatmap_score_exported
+    heatmap_score_combined = heatmap_score_delivered - heatmap_score_exported
+
+    df[HEATMAP_DELIVERED] = heatmap_score_delivered
+    df[HEATMAP_EXPORTED] = heatmap_score_exported
+    df[HEATMAP_TOTAL] = heatmap_score_combined
+
+    if not inplace:
+        return df
+    return None
+
+
+def calculate_dyntar_columns(df: pd.DataFrame, inplace: bool = False) -> Optional[pd.DataFrame]:
+    """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)
+
+    if not inplace:
+        return df
+    return None

openenergyid/dyntar/models.py

@@ -0,0 +1,66 @@
+"""Models for dynamic tariff analysis."""
+
+from typing import Literal
+from pydantic import Field, conlist
+
+from openenergyid.models import TimeDataFrame
+
+
+RequiredColumns = Literal[
+    "electricity_delivered",
+    "electricity_exported",
+    "price_electricity_delivered",
+    "price_electricity_exported",
+    "RLP",
+    "SPP",
+]
+
+OutputColumns = Literal[
+    "electricity_delivered_smr3",
+    "electricity_exported_smr3",
+    "price_electricity_delivered",
+    "price_electricity_exported",
+    "RLP",
+    "SPP",
+    "electricity_delivered_smr2",
+    "electricity_exported_smr2",
+    "cost_electricity_delivered_smr2",
+    "cost_electricity_exported_smr2",
+    "cost_electricity_delivered_smr3",
+    "cost_electricity_exported_smr3",
+    "rlp_weighted_price_delivered",
+    "spp_weighted_price_exported",
+    "heatmap_delivered",
+    "heatmap_exported",
+    "heatmap_total",
+]
+
+
+class DynamicTariffAnalysisInput(TimeDataFrame):
+    """Input frame for dynamic tariff analysis."""
+
+    columns: list[RequiredColumns] = Field(
+        min_length=len(RequiredColumns.__args__),
+        max_length=len(RequiredColumns.__args__),
+        examples=[RequiredColumns.__args__],
+    )
+    data: list[
+        conlist(
+            item_type=float,
+            min_length=len(RequiredColumns.__args__),
+            max_length=len(RequiredColumns.__args__),
+        )  # type: ignore
+    ] = Field(examples=[[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]])
+
+
+class DynamicTariffAnalysisOutput(TimeDataFrame):
+    """Output frame for dynamic tariff analysis."""
+
+    columns: list[OutputColumns] = Field(
+        min_length=1,
+        max_length=len(OutputColumns.__args__),
+        examples=[OutputColumns.__args__],
+    )
+    data: list[
+        conlist(item_type=float, min_length=1, max_length=len(OutputColumns.__args__))  # type: ignore
+    ] = Field(examples=[[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]])

openenergyid/energysharing/__init__.py

@@ -0,0 +1,6 @@
+"""Energy Sharing package."""
+
+from .main import calculate
+from .models import CalculationMethod, EnergySharingInput, EnergySharingOutput
+
+__all__ = ["calculate", "CalculationMethod", "EnergySharingInput", "EnergySharingOutput"]

openenergyid/energysharing/const.py

@@ -0,0 +1,8 @@
+"""Constants for the energysharing module."""
+
+GROSS_INJECTION = "Gross Injection"
+NET_INJECTION = "Net Injection"
+GROSS_OFFTAKE = "Gross Offtake"
+NET_OFFTAKE = "Net Offtake"
+KEY = "Key"
+SHARED_ENERGY = "Shared Energy"

openenergyid/energysharing/data_formatting.py

@@ -0,0 +1,73 @@
+"""Functions to create multi-indexed DataFrames for input and output data for energy sharing."""
+
+import pandas as pd
+from .const import GROSS_INJECTION, GROSS_OFFTAKE, KEY, NET_INJECTION, NET_OFFTAKE, SHARED_ENERGY
+
+
+def create_multi_index_input_frame(
+    gross_injection: pd.DataFrame,
+    gross_offtake: pd.DataFrame,
+    key: pd.DataFrame,
+) -> pd.DataFrame:
+    """Create a multi-indexed DataFrame with the input data for energy sharing."""
+    gross_injection = gross_injection.copy()
+    gross_offtake = gross_offtake.copy()
+    key = key.copy()
+
+    gross_injection.columns = pd.MultiIndex.from_product(
+        [[GROSS_INJECTION], gross_injection.columns]
+    )
+    gross_offtake.columns = pd.MultiIndex.from_product([[GROSS_OFFTAKE], gross_offtake.columns])
+    key.columns = pd.MultiIndex.from_product([[KEY], key.columns])
+
+    df = pd.concat([gross_injection, gross_offtake, key], axis=1)
+
+    # Do a check that the sum of the keys per timestamp is 1
+    assert df[KEY].dropna(how="all").sum(axis=1).round(2).eq(1).all()
+
+    return df
+
+
+def create_multi_index_output_frame(
+    net_injection: pd.DataFrame,
+    net_offtake: pd.DataFrame,
+    shared_energy: pd.DataFrame,
+) -> pd.DataFrame:
+    """Create a multi-indexed DataFrame with the output data for energy sharing."""
+    net_injection = net_injection.copy()
+    net_offtake = net_offtake.copy()
+    shared_energy = shared_energy.copy()
+
+    net_injection.columns = pd.MultiIndex.from_product([[NET_INJECTION], net_injection.columns])
+    net_offtake.columns = pd.MultiIndex.from_product([[NET_OFFTAKE], net_offtake.columns])
+    shared_energy.columns = pd.MultiIndex.from_product([[SHARED_ENERGY], shared_energy.columns])
+
+    df = pd.concat([net_injection, net_offtake, shared_energy], axis=1)
+
+    df = df.round(2)
+    return df
+
+
+def result_to_input_for_reiteration(result: pd.DataFrame, key: pd.DataFrame) -> pd.DataFrame:
+    """Create a multi-indexed DataFrame with the input data for energy sharing after the first iteration."""
+    # We iterate again. The net injection of the previous result is taken as gross injection input
+    # And the net offtake is taken as the gross offtake input
+    # When a user's net offtake is 0, the key is set to 0; and the keys are re-normalized
+
+    gross_injection = result[NET_INJECTION].copy()
+    gross_offtake = result[NET_OFFTAKE].copy()
+
+    # Take the original key, but replace the value with 0.0 if result[NET_OFFTAKE] is 0.0
+
+    key = key.copy()
+    key = key.where(~result[NET_OFFTAKE].eq(0), 0)
+
+    # Re-normalize the keys
+
+    key = key.div(key.sum(axis=1), axis=0)
+
+    df = create_multi_index_input_frame(
+        gross_injection=gross_injection, gross_offtake=gross_offtake, key=key
+    )
+
+    return df

openenergyid/energysharing/main.py

@@ -0,0 +1,110 @@
+"""Main Calcuation Module for Energy Sharing."""
+
+import pandas as pd
+from .models import CalculationMethod
+from .const import GROSS_INJECTION, GROSS_OFFTAKE, KEY, NET_INJECTION, NET_OFFTAKE, SHARED_ENERGY
+from .data_formatting import create_multi_index_output_frame, result_to_input_for_reiteration
+
+
+def _calculate(df: pd.DataFrame, method: CalculationMethod) -> pd.DataFrame:
+    """Calculate the energy sharing for the given input data. This function is not iterative."""
+    # Step 1: Calculate the maximum available gross injection that can be shared
+    # A participant cannot share their injection with themselves
+
+    # Take the injection of P1, and divide it per participant as per their key
+
+    injections_to_share = []
+    rest = {}
+
+    for participant in df.columns.levels[1]:
+        injection_to_share = df[GROSS_INJECTION][participant].copy()
+
+        if method == CalculationMethod.RELATIVE or method == CalculationMethod.OPTIMAL:
+            # Set the key of the current participant to 0
+            # Re-normalize the keys for the other participants
+            key = df[KEY].copy()
+            key.loc[:, participant] = 0
+            key = key.div(key.sum(axis=1), axis=0)
+        elif method == CalculationMethod.FIXED:
+            key = df[KEY].copy()
+
+        # Multiply injection_to_share with the key of each participant
+        shared_by_participant = (injection_to_share * key.T).T
+        shared_by_participant.fillna(0, inplace=True)
+        # Set the value for the current participant to 0
+        shared_by_participant.loc[:, participant] = 0
+
+        # Put the not shared injection in the rest
+        rest[participant] = injection_to_share - shared_by_participant.sum(axis=1)
+
+        injections_to_share.append(shared_by_participant)
+
+    # Sum the injections to share
+    max_allocated_injection = sum(injections_to_share)
+
+    # Concat the rest
+    injection_that_cannot_be_shared = pd.concat(rest, axis=1)
+
+    # Step 2: Calculate the Net Offtake, by assigning the injections to each participant
+    # But, a participant cannot receive more than their offtake
+
+    net_offtake = df[GROSS_OFFTAKE] - max_allocated_injection
+
+    # Sum all negative values into a column "Not Shared"
+    not_shared_after_assignment = net_offtake.clip(upper=0).sum(axis=1) * -1
+
+    # Clip the values to 0
+    net_offtake = net_offtake.clip(lower=0)
+
+    # Calculate the amount of actual shared energy
+    # This is the difference between the gross offtake and the net offtake
+    shared_energy = df[GROSS_OFFTAKE] - net_offtake
+
+    # Step 3: Assign the Rests back to the original injectors
+
+    # The energy that is not shared after assignment
+    # should be divided back to the original injectors
+    # A ratio of the original injection should be used
+
+    re_distributed_not_shared = (
+        (df[GROSS_INJECTION].T / df[GROSS_INJECTION].sum(axis=1)) * not_shared_after_assignment
+    ).T
+    re_distributed_not_shared.fillna(0, inplace=True)
+
+    # The nett injection is the sum of:
+    # the injection that cannot be shared to begin with
+    # (because participants cannot share with themselves)
+    # and the injection that cannot be shared after assignment
+    # (because participants cannot receive more than their offtake)
+
+    net_injection = injection_that_cannot_be_shared + re_distributed_not_shared
+
+    result = create_multi_index_output_frame(
+        net_injection=net_injection, net_offtake=net_offtake, shared_energy=shared_energy
+    )
+
+    return result
+
+
+def calculate(df: pd.DataFrame, method: CalculationMethod) -> pd.DataFrame:
+    """Calculate the energy sharing for the given input data.
+
+    This function is iterative if the method is optimal."""
+    result = _calculate(df, method)
+
+    if method in [CalculationMethod.FIXED, CalculationMethod.RELATIVE]:
+        return result
+
+    # Optimal method, we iterate until the amount of shared energy is 0
+    final_result = result.copy()
+    while not result[SHARED_ENERGY].eq(0).all().all():
+        df = result_to_input_for_reiteration(result, df[KEY])
+        result = _calculate(df, method)
+
+        # Add the result to the final result
+        # Overwrite NET_INJECTION and NET_OFFTAKE, Sum SHARED_ENERGY
+        final_result[NET_INJECTION] = result[NET_INJECTION]
+        final_result[NET_OFFTAKE] = result[NET_OFFTAKE]
+        final_result[SHARED_ENERGY] += result[SHARED_ENERGY]
+
+    return final_result

openenergyid/energysharing/models.py

@@ -0,0 +1,55 @@
+"""Data models for energy sharing."""
+
+from enum import Enum
+from typing import Annotated
+
+from pydantic import BaseModel, Field
+import pandas as pd
+
+from openenergyid import TimeDataFrame
+from .data_formatting import create_multi_index_input_frame
+from .const import NET_INJECTION, NET_OFFTAKE, SHARED_ENERGY
+
+
+class CalculationMethod(Enum):
+    """Calculation method for energy sharing."""
+
+    FIXED = "Fixed"
+    RELATIVE = "Relative"
+    OPTIMAL = "Optimal"
+
+
+class EnergySharingInput(BaseModel):
+    """Input data for energy sharing."""
+
+    gross_injection: Annotated[TimeDataFrame, Field(alias="grossInjection")]
+    gross_offtake: Annotated[TimeDataFrame, Field(alias="grossOfftake")]
+    key: Annotated[TimeDataFrame, Field(alias="key")]
+    timezone: str = Field(alias="timeZone", default="Europe/Brussels")
+
+    def data_frame(self) -> pd.DataFrame:
+        """Return the data as a combined DataFrame"""
+        df = create_multi_index_input_frame(
+            gross_injection=self.gross_injection.to_pandas(),
+            gross_offtake=self.gross_offtake.to_pandas(),
+            key=self.key.to_pandas(),
+        )
+        df = df.tz_convert(self.timezone)
+        return df
+
+
+class EnergySharingOutput(BaseModel):
+    """Output data for energy sharing."""
+
+    net_injection: TimeDataFrame = Field(alias="netInjection")
+    net_offtake: TimeDataFrame = Field(alias="netOfftake")
+    shared_energy: TimeDataFrame = Field(alias="sharedEnergy")
+
+    @classmethod
+    def from_calculation_result(cls, result: pd.DataFrame) -> "EnergySharingOutput":
+        """Create an output model from a calculation result."""
+        return cls.model_construct(
+            net_injection=TimeDataFrame.from_pandas(result[NET_INJECTION]),
+            net_offtake=TimeDataFrame.from_pandas(result[NET_OFFTAKE]),
+            shared_energy=TimeDataFrame.from_pandas(result[SHARED_ENERGY]),
+        )

openenergyid/models.py

@@ -1,67 +1,119 @@
 """Data models for the Open Energy ID."""
 
 import datetime as dt
-from typing import Optional, overload
+from typing import Optional, overload, Union
+
+try:
+    from typing import Self
+except ImportError:
+    from typing_extensions import Self
 
 import pandas as pd
 from pydantic import BaseModel
 
 
-class TimeSeries(BaseModel):
-    """Time series data."""
+class TimeSeriesBase(BaseModel):
+    """Pydantic base model for time series data."""
 
-    columns: list[str]
     index: list[dt.datetime]
-    data: list[list[float]]
 
     @classmethod
-    def from_pandas(cls, data: pd.DataFrame) -> "TimeSeries":
-        """Create a MultiVariableRegressionInputFrame from a pandas DataFrame."""
-        return cls.model_validate(data.to_dict(orient="split"))
+    def from_pandas(cls, data: Union[pd.Series, pd.DataFrame]) -> Self:
+        """Create from a Pandas Object."""
+        raise NotImplementedError
 
-    def to_pandas(self, timezone: str = "UTC") -> pd.DataFrame:
-        """Convert the MultiVariableRegressionInputFrame to a pandas DataFrame."""
-        frame = pd.DataFrame(self.data, columns=self.columns, index=self.index)
-        frame.index = pd.to_datetime(frame.index, utc=True)
-        return frame.tz_convert(timezone)
+    def to_pandas(self, timezone: str = "UTC") -> Union[pd.Series, pd.DataFrame]:
+        """Convert to a Pandas Object."""
+        raise NotImplementedError
 
     @overload
     def to_json(self, path: None = None, **kwargs) -> str:
-        ...
+        """Dump to a JSON string."""
 
     @overload
     def to_json(self, path: str, **kwargs) -> None:
-        ...
+        """Dump to a JSON file."""
 
     def to_json(self, path: Optional[str] = None, **kwargs) -> Optional[str]:
-        """Save the TimeSeries to a JSON file or return as string."""
+        """Dump to a JSON string or file."""
         if path is None:
             return self.model_dump_json(**kwargs)
-        else:
-            encoding = kwargs.pop("encoding", "UTF-8")
-            with open(path, "w", encoding=encoding) as file:
-                file.write(self.model_dump_json(**kwargs))
+        encoding = kwargs.pop("encoding", "UTF-8")
+        with open(path, "w", encoding=encoding) as file:
+            file.write(self.model_dump_json(**kwargs))
+        return None
 
     @overload
     @classmethod
-    def from_json(cls, string: str, **kwargs) -> "TimeSeries":
-        ...
+    def from_json(cls, string: str, **kwargs) -> Self:
+        """Load from a JSON string."""
 
     @overload
     @classmethod
-    def from_json(cls, path: str, **kwargs) -> "TimeSeries":
-        ...
+    def from_json(cls, path: str, **kwargs) -> Self:
+        """Load from a JSON file."""
 
     @classmethod
-    def from_json(
-        cls, string: Optional[str] = None, path: Optional[str] = None, **kwargs
-    ) -> "TimeSeries":
-        """Load the TimeSeries from a JSON file or string."""
+    def from_json(cls, string: Optional[str] = None, path: Optional[str] = None, **kwargs) -> Self:
+        """Load from a JSON file or string."""
         if string:
             return cls.model_validate_json(string, **kwargs)
-        elif path:
+        if path:
             encoding = kwargs.pop("encoding", "UTF-8")
             with open(path, "r", encoding=encoding) as file:
                 return cls.model_validate_json(file.read(), **kwargs)
-        else:
-            raise ValueError("Either string or path must be provided.")
+        raise ValueError("Either string or path must be provided.")
+
+
+class TimeSeries(TimeSeriesBase):
+    """Time series data with a single column."""
+
+    name: Union[str, None] = None
+    data: list[float]
+
+    @classmethod
+    def from_pandas(cls, data: pd.Series) -> Self:
+        """Create from a Pandas Series."""
+        return cls.model_construct(name=data.name, data=data.tolist(), index=data.index.tolist())
+
+    def to_pandas(self, timezone: str = "UTC") -> pd.Series:
+        """Convert to a Pandas Series."""
+        series = pd.Series(self.data, name=self.name, index=self.index)
+        series.index = pd.to_datetime(series.index, utc=True)
+        return series.tz_convert(timezone)
+
+
+class TimeDataFrame(TimeSeriesBase):
+    """Time series data with multiple columns."""
+
+    columns: list[str]
+    data: list[list[float]]
+
+    @classmethod
+    def from_pandas(cls, data: pd.DataFrame) -> Self:
+        """Create from a Pandas DataFrame."""
+        return cls.model_construct(
+            columns=data.columns.tolist(), data=data.values.tolist(), index=data.index.tolist()
+        )
+
+    def to_pandas(self, timezone: str = "UTC") -> pd.DataFrame:
+        """Convert to a Pandas DataFrame."""
+        frame = pd.DataFrame(self.data, columns=self.columns, index=self.index)
+        frame.index = pd.to_datetime(frame.index, utc=True)
+        return frame.tz_convert(timezone)
+
+    @classmethod
+    def from_timeseries(cls, data: list[TimeSeries]) -> Self:
+        """Create from a list of TimeSeries objects."""
+        return cls.model_construct(
+            columns=[series.name for series in data],
+            data=[series.data for series in data],
+            index=data[0].index,
+        )
+
+    def to_timeseries(self) -> list[TimeSeries]:
+        """Convert to a list of TimeSeries objects."""
+        return [
+            TimeSeries(name=column, data=column_data, index=self.index)
+            for column, column_data in zip(self.columns, self.data)
+        ]

openenergyid/mvlr/helpers.py

@@ -4,7 +4,7 @@ import pandas as pd
 
 from openenergyid.enums import Granularity
 
-pandas_granularity_map = {Granularity.P7D: "W-MON", Granularity.P1M: "MS"}
+pandas_granularity_map = {Granularity.P7D: "W-MON", Granularity.P1M: "MS", Granularity.P1D: "D"}
 
 
 def resample_input_data(

openenergyid/mvlr/models.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel, Field, ConfigDict
 import statsmodels.formula.api as fm
 
 from openenergyid.enums import Granularity
-from openenergyid.models import TimeSeries
+from openenergyid.models import TimeDataFrame
 
 from .mvlr import MultiVariableLinearRegression
 
@@ -66,7 +66,7 @@ class MultiVariableRegressionInput(BaseModel):
         alias="independentVariables", min_length=1
     )
     dependent_variable: str = Field(alias="dependentVariable")
-    frame: TimeSeries
+    frame: TimeDataFrame
     granularities: list[Granularity]
     allow_negative_predictions: bool = Field(alias="allowNegativePredictions", default=False)
     validation_parameters: ValidationParameters = Field(
@@ -195,7 +195,7 @@ class MultiVariableRegressionResult(BaseModel):
     prob_f_stat: float = Field(ge=0, le=1, alias="probFStat")
     intercept: IndependentVariableResult
     granularity: Granularity
-    frame: TimeSeries
+    frame: TimeDataFrame
 
     model_config = ConfigDict(populate_by_name=True)
 
@@ -225,5 +225,5 @@ class MultiVariableRegressionResult(BaseModel):
             prob_f_stat=mvlr.fit.f_pvalue,
             intercept=IndependentVariableResult.from_fit(mvlr.fit, "Intercept"),
             granularity=mvlr.granularity,
-            frame=TimeSeries.from_pandas(frame),
+            frame=TimeDataFrame.from_pandas(frame),
         )

{openenergyid-0.1.9.dist-info → openenergyid-0.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: openenergyid
-Version: 0.1.9
+Version: 0.1.12
 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.12.dist-info/RECORD

@@ -0,0 +1,22 @@
+openenergyid/__init__.py,sha256=5EauuvlNmYacZW0kJXDfcpOSZWOwSlzX640snXiX92E,193
+openenergyid/const.py,sha256=D-xUnUyVuLmphClkePgxpFP6z0RDhw_6m7rX0BHBgrw,823
+openenergyid/enums.py,sha256=jdw4CB1gkisx0re_SesrTEyh_T-UxYp6uieE7iYlHdA,357
+openenergyid/models.py,sha256=ANdbdtr6JccSz6zEZj0TQOXISGPdtJPQy4t17uub97E,3975
+openenergyid/dyntar/__init__.py,sha256=iQXQXrEQOiVNeeF6LRmUf3oOhKlGjMNF7o4T04IWTGA,371
+openenergyid/dyntar/const.py,sha256=K7X6nHIl9DNyC6hU8jLtvOy3-IBGuYC449evOpImuJE,773
+openenergyid/dyntar/main.py,sha256=sn2zN5ep8XBgSGR_UDBU6mdp1WKNLzxROwp8HWCDgCM,5316
+openenergyid/dyntar/models.py,sha256=BbGdHj7eUOMepblWJNsNd21xULluv6m7TtdhSggvVbY,1873
+openenergyid/energysharing/__init__.py,sha256=swGqqgTh6DS2wFhnKs4CtnVMVrQNs6kv1BAzwgo0MQA,229
+openenergyid/energysharing/const.py,sha256=X2zEPtTlsmZ66w6RmLS_h8NmdzObAEi5N6-0yrLN5V4,219
+openenergyid/energysharing/data_formatting.py,sha256=ruAPa_Qbg6PMoUSObnhIYz5y-BeK92WlsOpLIdNXaeg,2736
+openenergyid/energysharing/main.py,sha256=2AWaTysNVLZEFVs8yRmFWx1_qG-NPeAazWXlFLHfLRM,4409
+openenergyid/energysharing/models.py,sha256=Bh7Nj_PFoCIKwdI7k4d_RrJnaiubT3dN2eIn5P4Xam4,1894
+openenergyid/mvlr/__init__.py,sha256=Glrc218oqa8tq_Y2G9LXaSoN4Yba-vsjXUi9r9iPzaY,471
+openenergyid/mvlr/helpers.py,sha256=Uzbfrj3IpH26wA206KOl0hNucKE-n9guJNC_EROBVKA,983
+openenergyid/mvlr/main.py,sha256=cn7jZ98cHn2eh-0zG9q8Pad0Ft_FuI-u3a-eeHeF8jA,1304
+openenergyid/mvlr/models.py,sha256=qi5NWeQC1KeWEAO8KglgVM1xbHM5QoeK25ugn0W_X6c,8628
+openenergyid/mvlr/mvlr.py,sha256=F7WvWnZQtqUmK1vsguemsn9n8pDDk3tQ1weOlv-bo0c,18626
+openenergyid-0.1.12.dist-info/METADATA,sha256=5wBSQdBWuoeh8YMuW-pU9Y9VeK3gRhK9QG18zMZf1kM,2432
+openenergyid-0.1.12.dist-info/WHEEL,sha256=fl6v0VwpzfGBVsGtkAkhILUlJxROXbA3HvRL6Fe3140,105
+openenergyid-0.1.12.dist-info/licenses/LICENSE,sha256=NgRdcNHwyXVCXZ8sJwoTp0DCowThJ9LWWl4xhbV1IUY,1074
+openenergyid-0.1.12.dist-info/RECORD,,

{openenergyid-0.1.9.dist-info → openenergyid-0.1.12.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.21.1
+Generator: hatchling 1.25.0
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

openenergyid-0.1.9.dist-info/RECORD

@@ -1,13 +0,0 @@
-openenergyid/__init__.py,sha256=_KWarhaNa9a-pxb9L4P7NUtWUi8A2CVl9nD29g21mYs,160
-openenergyid/const.py,sha256=bF-U-r0Qj2GWCYBBxReg8fbv2D0V1JzfPMwSEQ5ZWds,569
-openenergyid/enums.py,sha256=jdw4CB1gkisx0re_SesrTEyh_T-UxYp6uieE7iYlHdA,357
-openenergyid/models.py,sha256=pUJpQCodph0NukiIpFdc9X6Zj6qEGQPSWoztYDwqyuE,2214
-openenergyid/mvlr/__init__.py,sha256=Glrc218oqa8tq_Y2G9LXaSoN4Yba-vsjXUi9r9iPzaY,471
-openenergyid/mvlr/helpers.py,sha256=fsx-gSvBdU31BjncFkRd1RySmSPPYgwflCnmSFzox2Q,961
-openenergyid/mvlr/main.py,sha256=cn7jZ98cHn2eh-0zG9q8Pad0Ft_FuI-u3a-eeHeF8jA,1304
-openenergyid/mvlr/models.py,sha256=SdZYroi3EM4D1U6OnnyfBv6ygzfAQM2UzICg0jaQD6w,8616
-openenergyid/mvlr/mvlr.py,sha256=F7WvWnZQtqUmK1vsguemsn9n8pDDk3tQ1weOlv-bo0c,18626
-openenergyid-0.1.9.dist-info/METADATA,sha256=8BhGlQs47GfSa2XnCp3Hb9vQE_eE0vtSo7RoSAH3Mx8,2431
-openenergyid-0.1.9.dist-info/WHEEL,sha256=ccEkY-EGGllEs7ySpwBlD8G4u70wR77CNej8Q6tzIqA,105
-openenergyid-0.1.9.dist-info/licenses/LICENSE,sha256=NgRdcNHwyXVCXZ8sJwoTp0DCowThJ9LWWl4xhbV1IUY,1074
-openenergyid-0.1.9.dist-info/RECORD,,