openenergyid 0.1.31__py3-none-any.whl

openenergyid/pvsim/pvlib/weather.py

@@ -0,0 +1,91 @@
+"""
+Weather data utilities for PV simulation.
+
+Provides functions to retrieve and process weather data for PV simulations,
+including timezone-aware handling and leap year adjustments.
+"""
+
+import datetime as dt
+import typing
+
+import pandas as pd
+import pvlib
+
+
+def get_utc_offset_on_1_jan(timezone: str) -> int:
+    """
+    Get the UTC offset in hours for the given timezone on January 1st.
+
+    Args:
+        timezone: The timezone string (e.g., "Europe/Amsterdam").
+
+    Returns:
+        The UTC offset in hours as an integer.
+
+    Raises:
+        ValueError: If the UTC offset cannot be determined.
+    """
+    jan_first = pd.Timestamp("2020-01-01 00:00:00", tz=timezone)
+    utc_offset = jan_first.utcoffset()
+    if utc_offset is None:
+        raise ValueError(f"Could not determine UTC offset for timezone {timezone}")
+    return int(utc_offset.total_seconds() / 3600)
+
+
+def get_weather(
+    latitude: float, longitude: float, start: dt.date, end: dt.date, tz: str
+) -> pd.DataFrame:
+    """
+    Retrieve and process weather data for the specified location and date range.
+
+    Downloads a "normal year" TMY dataset from PVGIS, aligns it to the requested
+    date range and timezone, and handles leap year adjustments.
+
+    Args:
+        latitude: Latitude of the location.
+        longitude: Longitude of the location.
+        start: Start date (inclusive).
+        end: End date (exclusive).
+        tz: Timezone string.
+
+    Returns:
+        A pandas DataFrame indexed by timestamp with weather data.
+    """
+    # Get a "normal year" from pvgis, it will be indexed in 1990
+    utc_offset = get_utc_offset_on_1_jan(tz)
+    weather = pvlib.iotools.get_pvgis_tmy(
+        latitude=latitude, longitude=longitude, roll_utc_offset=utc_offset
+    )[0]
+    weather = typing.cast(pd.DataFrame, weather)
+    weather = weather.tz_convert(tz)
+    weather.index.name = None
+
+    # Check if 29 februari is included in the weather data
+    weather_index = typing.cast(pd.DatetimeIndex, weather.index)
+    leap_included = "02-29" in weather_index.strftime("%m-%d").unique()
+
+    # Construct our desired index
+    new_index = pd.date_range(start, end, freq="15min", tz=tz)
+    temp_df = pd.DataFrame(index=new_index)
+    # Add a key that doesn't contain year
+    temp_df["tkey"] = new_index.tz_convert("UTC").strftime("%m-%dT%H:%M:%S%z")
+    temp_df["timestamp"] = new_index
+    if not leap_included:
+        # Replace all tkey's starting with "02-29" with "02-28"
+        temp_df.loc[temp_df.tkey.str.startswith("02-29"), "tkey"] = temp_df.loc[
+            temp_df.tkey.str.startswith("02-29"), "tkey"
+        ].str.replace("02-29", "02-28")
+
+    # Add the key to the weather frame and join
+    weather["tkey"] = weather_index.tz_convert("UTC").strftime("%m-%dT%H:%M:%S%z")
+    df = (
+        pd.merge(temp_df, weather, on="tkey", how="left")
+        .set_index("timestamp")
+        .drop(columns=["tkey"])
+    )
+
+    # Interpolate and drop last value
+    df = df.interpolate(method="time")
+    df = df.iloc[:-1]
+
+    return df

openenergyid/sim/__init__.py

@@ -0,0 +1,5 @@
+"""Main Simulation Package that can handle every simulation."""
+
+from .main import ExAnteData, FullSimulationInput, run_simulation
+
+__all__ = ["FullSimulationInput", "run_simulation", "ExAnteData"]

openenergyid/sim/main.py

@@ -0,0 +1,67 @@
+"""Generic Simulation Analysis Module."""
+
+from typing import Annotated, Union
+
+import aiohttp
+from pydantic import BaseModel, Field
+
+from ..abstractsim import SimulationSummary, Simulator
+from ..pvsim import PVSimulationInput, apply_simulation
+from ..pvsim import get_simulator as get_pv_simulator
+from ..simeval import EvaluationInput, compare_results, evaluate
+from ..simeval.models import Frequency
+
+# Here we define all types of simulations
+SimulationInput = Annotated[Union[PVSimulationInput], Field(discriminator="type")]
+
+
+def get_simulator(input_: SimulationInput) -> Simulator:
+    """Get an instance of the simulator based on the input data."""
+    # Only PV simulators for now
+    return get_pv_simulator(input_)
+
+
+class ExAnteData(EvaluationInput):
+    """Ex-ante data for simulation analysis."""
+
+
+class FullSimulationInput(BaseModel):
+    """Full input for running a simulation analysis."""
+
+    ex_ante_data: ExAnteData
+    simulation_parameters: SimulationInput
+    timezone: str = "Europe/Brussels"
+    return_frequencies: list[Frequency] | None = Field(
+        default=None,
+        examples=["MS", "W-MON"],
+        description="Optional list of frequencies that should be included in the analysis. Be default, only `total` is included, but you can add more here. Uses the Pandas freqstr.",
+    )
+
+
+async def run_simulation(
+    input_: FullSimulationInput, session: aiohttp.ClientSession
+) -> SimulationSummary:
+    """Run the full simulation analysis workflow."""
+    df = input_.ex_ante_data.to_pandas(timezone=input_.timezone)
+
+    ex_ante_eval = evaluate(df, return_frequencies=input_.return_frequencies)
+
+    simulator: Simulator = get_simulator(input_.simulation_parameters)
+    await simulator.load_resources(session=session)
+
+    sim_eval = evaluate(simulator.result_as_frame(), return_frequencies=input_.return_frequencies)
+
+    df_post = apply_simulation(df, simulator.simulation_results)
+
+    post_eval = evaluate(df_post, return_frequencies=input_.return_frequencies)
+
+    comparison = compare_results(ex_ante_eval, post_eval)
+
+    summary = SimulationSummary.from_simulation(
+        ex_ante=ex_ante_eval,
+        simulation_result=sim_eval,
+        ex_post=post_eval,
+        comparison=comparison,
+    )
+
+    return summary

openenergyid/simeval/__init__.py

@@ -0,0 +1,6 @@
+"""Module containing basic evaluation functions for energy systems."""
+
+from .main import compare_results, evaluate
+from .models import EvaluationInput, EvaluationOutput
+
+__all__ = ["EvaluationInput", "EvaluationOutput", "evaluate", "compare_results"]

openenergyid/simeval/main.py

@@ -0,0 +1,148 @@
+"""Module for evaluating energy simulation data."""
+
+import typing
+
+import numpy as np
+import pandas as pd
+
+from .. import const
+
+
+def evaluate(
+    data: pd.DataFrame, return_frequencies: list[str] | None = None
+) -> dict[str, pd.DataFrame | pd.Series]:
+    """Evaluate the data and return resampled results.
+
+    Args:
+        data: A pandas DataFrame containing time series data with columns:
+            - electricity_delivered
+            - electricity_exported
+            - electricity_produced
+        return_frequencies: List of pandas offset aliases for resampling frequencies.
+            Defaults to ['MS'] (Month Start) if None.
+
+    Returns:
+        A dictionary with keys as frequencies and values as resampled DataFrames.
+    """
+    evaluator = Evaluator(data=data, return_frequencies=return_frequencies)
+    return evaluator.evaluate()
+
+
+class Evaluator:
+    """Evaluator for basic energy system evaluation."""
+
+    def __init__(self, data: pd.DataFrame, return_frequencies: list[str] | None = None):
+        """Initialize the evaluator with data and return frequencies."""
+        self.data = data.copy()
+        if return_frequencies is None:
+            self.return_frequencies = []
+        else:
+            self.return_frequencies = return_frequencies
+
+    def evaluate(self) -> dict[str, pd.DataFrame | pd.Series]:
+        """Evaluate the data and return resampled results."""
+        if const.ELECTRICITY_DELIVERED not in self.data.columns:
+            self.data[const.ELECTRICITY_DELIVERED] = float("NaN")
+        if const.ELECTRICITY_EXPORTED not in self.data.columns:
+            self.data[const.ELECTRICITY_EXPORTED] = float("NaN")
+        if const.ELECTRICITY_PRODUCED not in self.data.columns:
+            self.data[const.ELECTRICITY_PRODUCED] = float("NaN")
+        if const.PRICE_ELECTRICITY_DELIVERED not in self.data.columns:
+            self.data[const.PRICE_ELECTRICITY_DELIVERED] = float("NaN")
+        if const.PRICE_ELECTRICITY_EXPORTED not in self.data.columns:
+            self.data[const.PRICE_ELECTRICITY_EXPORTED] = float("NaN")
+
+        # Add electricy_consumed
+        self.data[const.ELECTRICITY_CONSUMED] = (
+            self.data[const.ELECTRICITY_DELIVERED]
+            - self.data[const.ELECTRICITY_EXPORTED].fillna(0.0)
+            + self.data[const.ELECTRICITY_PRODUCED].fillna(0.0)
+        ).clip(lower=0)
+
+        # Add electricy_self_consumed
+        self.data[const.ELECTRICITY_SELF_CONSUMED] = (
+            self.data[const.ELECTRICITY_PRODUCED] - self.data[const.ELECTRICITY_EXPORTED]
+        ).clip(lower=0)
+
+        # Add costs
+        self.data[const.COST_ELECTRICITY_DELIVERED] = (
+            self.data[const.ELECTRICITY_DELIVERED] * self.data[const.PRICE_ELECTRICITY_DELIVERED]
+        )
+        self.data[const.EARNINGS_ELECTRICITY_EXPORTED] = (
+            self.data[const.ELECTRICITY_EXPORTED] * self.data[const.PRICE_ELECTRICITY_EXPORTED]
+        )
+        self.data[const.COST_ELECTRICITY_NET] = (
+            self.data[const.COST_ELECTRICITY_DELIVERED]
+            - self.data[const.EARNINGS_ELECTRICITY_EXPORTED]
+        )
+
+        # Calculate sums
+        results: dict[str, pd.DataFrame | pd.Series] = {}
+        results["total"] = (
+            self.data[
+                [
+                    const.ELECTRICITY_DELIVERED,
+                    const.ELECTRICITY_EXPORTED,
+                    const.ELECTRICITY_PRODUCED,
+                    const.ELECTRICITY_CONSUMED,
+                    const.ELECTRICITY_SELF_CONSUMED,
+                    const.COST_ELECTRICITY_DELIVERED,
+                    const.EARNINGS_ELECTRICITY_EXPORTED,
+                    const.COST_ELECTRICITY_NET,
+                ]
+            ]
+            .dropna(axis=1, how="all")
+            .sum()
+        )
+
+        for freq in self.return_frequencies:
+            resampled = (
+                self.data[
+                    [
+                        const.ELECTRICITY_DELIVERED,
+                        const.ELECTRICITY_EXPORTED,
+                        const.ELECTRICITY_PRODUCED,
+                        const.ELECTRICITY_CONSUMED,
+                        const.ELECTRICITY_SELF_CONSUMED,
+                        const.COST_ELECTRICITY_DELIVERED,
+                        const.EARNINGS_ELECTRICITY_EXPORTED,
+                        const.COST_ELECTRICITY_NET,
+                    ]
+                ]
+                .dropna(axis=1, how="all")
+                .resample(freq)
+                .sum()
+            )
+            results[freq] = resampled
+
+        # Add ratios
+        for _, frame in results.items():
+            if const.ELECTRICITY_SELF_CONSUMED in frame:
+                frame[const.RATIO_SELF_CONSUMPTION] = np.divide(
+                    frame[const.ELECTRICITY_SELF_CONSUMED], frame[const.ELECTRICITY_PRODUCED]
+                )
+                frame[const.RATIO_SELF_SUFFICIENCY] = np.divide(
+                    frame[const.ELECTRICITY_SELF_CONSUMED],
+                    frame[const.ELECTRICITY_CONSUMED],
+                )
+        return results
+
+
+def compare_results(
+    res_1: dict[str, pd.DataFrame | pd.Series], res_2: dict[str, pd.DataFrame | pd.Series]
+) -> dict[str, dict[str, pd.Series | pd.DataFrame]]:
+    """Compare two evaluation results and return the differences."""
+    results = {}
+    for key in res_1.keys():
+        if key in res_2:
+            df_1 = res_1[key]
+            df_2 = res_2[key]
+            if isinstance(df_1, pd.Series) and isinstance(df_2, pd.Series):
+                df_1 = df_1.to_frame().T
+                df_2 = df_2.to_frame().T
+            df_1, df_2 = typing.cast(pd.DataFrame, df_1), typing.cast(pd.DataFrame, df_2)
+            diff = df_2 - df_1
+            results[key] = {}
+            results[key]["diff"] = diff.dropna(how="all", axis=1).squeeze(axis=0)
+            results[key]["ratio_diff"] = (diff / df_1).dropna(how="all", axis=1).squeeze(axis=0)
+    return results

openenergyid/simeval/models.py

@@ -0,0 +1,162 @@
+"""Models for basic energy system evaluation."""
+
+from typing import Annotated, Literal, Union
+
+from pydantic import BaseModel, Field, RootModel, StringConstraints, confloat, conlist
+
+from ..models import TimeDataFrame
+
+
+class EvaluationInput(TimeDataFrame):
+    """Input frame for basic energy system evaluation."""
+
+    columns: list[
+        Literal[
+            "electricity_delivered",
+            "electricity_exported",
+            "electricity_produced",
+            "price_electricity_delivered",
+            "price_electricity_exported",
+        ]
+    ] = Field(min_length=1, max_length=5)
+    data: list[conlist(item_type=confloat(allow_inf_nan=True), min_length=1, max_length=5)]  # type: ignore
+
+
+class EvaluationOutput(TimeDataFrame):
+    """Output frame for basic energy system evaluation."""
+
+    columns: list[
+        Literal[
+            "electricity_delivered",
+            "electricity_exported",
+            "electricity_produced",
+            "electricity_consumed",
+            "electricity_self_consumed",
+            "cost_electricity_delivered",
+            "earnings_electricity_exported",
+            "cost_electricity_net",
+            "ratio_self_consumption",
+            "ratio_self_sufficiency",
+        ]
+    ] = Field(min_length=1, max_length=10)
+    data: list[conlist(item_type=confloat(allow_inf_nan=True), min_length=1, max_length=10)]  # type: ignore
+
+
+# ---------- Reusable bits ----------
+
+Frequency = Annotated[
+    str,
+    StringConstraints(pattern=r"^(\d+min|H|D|W(?:-[A-Z]{3})?|MS|M|Q|QS|A|AS)$"),
+    Field(
+        title="Frequency key",
+        description=(
+            "Pandas-style frequency string (freqstr). "
+            "Typical examples: '15min', 'H', 'D', 'MS', 'W-MON'."
+        ),
+        examples=["15min", "H", "MS", "W-MON"],
+    ),
+]
+
+Metric = Annotated[
+    str,
+    Field(
+        description="Metric identifier.",
+        examples=[
+            "electricity_delivered",
+            "electricity_exported",
+            "electricity_produced",
+            "electricity_consumed",
+            "electricity_self_consumed",
+            "cost_electricity_delivered",
+            "earnings_electricity_exported",
+            "cost_electricity_net",
+            "ratio_self_consumption",
+            "ratio_self_sufficiency",
+        ],
+    ),
+]
+
+
+class MetricSummary(RootModel[dict[Metric, float]]):
+    """Total/aggregate values per metric (e.g. { 'electricity_delivered': 123.4 })."""
+
+    root: dict[Metric, float]
+
+
+# ---------- Eval payloads ----------
+# We model “either { 'total': MetricSummary } OR { '<freq>': EvaluationOutput, ... }”
+# as two schemas and present them via oneOf.
+
+
+class EvalTotals(BaseModel):
+    """Totals per metric (no time series)."""
+
+    total: MetricSummary = Field(
+        ..., description="Aggregate totals per metric over the full evaluation window."
+    )
+
+
+class EvalByFrequency(RootModel[dict[Frequency, EvaluationOutput]]):
+    """Per-frequency time series results."""
+
+    root: dict[Frequency, EvaluationOutput]
+
+
+EvalPayload = Annotated[
+    Union[EvalTotals, EvalByFrequency],
+    Field(description="Either totals-only, or per-frequency time series results."),
+]
+
+# ---------- Comparison payloads ----------
+# Shape:
+#   EITHER  { "total": { "diff": MetricSummary } } or { "total": { "ratio_diff": MetricSummary } }
+#   OR      { "<freq>": { "diff": EvaluationOutput } } or { "<freq>": { "ratio_diff": EvaluationOutput } }
+
+
+class DiffTotal(BaseModel):
+    """Totals-level absolute differences."""
+
+    diff: MetricSummary = Field(..., description="Absolute differences of totals.")
+
+
+class RatioDiffTotal(BaseModel):
+    """Totals-level relative (ratio) differences."""
+
+    ratio_diff: MetricSummary = Field(..., description="Relative (ratio) differences of totals.")
+
+
+class DiffTS(BaseModel):
+    """Time series absolute differences at a given frequency."""
+
+    diff: EvaluationOutput = Field(
+        ..., description="Absolute differences as a time series at this frequency."
+    )
+
+
+class RatioDiffTS(BaseModel):
+    """Time series relative (ratio) differences at a given frequency."""
+
+    ratio_diff: EvaluationOutput = Field(
+        ..., description="Relative (ratio) differences as a time series at this frequency."
+    )
+
+
+# Enforce exclusivity if you decide to combine diff/ratio into one model; here we keep them separate for clean docs.
+
+
+class ComparisonTotals(BaseModel):
+    """Totals comparison; pick exactly one of diff or ratio_diff by choosing the model."""
+
+    total: DiffTotal | RatioDiffTotal = Field(..., description="Totals-level comparison.")
+
+
+class ComparisonByFrequency(RootModel[dict[Frequency, Union[DiffTS, RatioDiffTS]]]):
+    """Per-frequency comparison; for each freq, pick diff or ratio_diff."""
+
+    root: dict[Frequency, DiffTS | RatioDiffTS]
+
+
+ComparisonPayload = Annotated[
+    Union[ComparisonTotals, ComparisonByFrequency],
+    Field(description="Comparison results at totals level or per-frequency."),
+]

openenergyid-0.1.31.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: openenergyid
+Version: 0.1.31
+Summary: Open Source Python library for energy analytics and simulations
+Author-email: Jan Pecinovsky <jan@energieid.be>, Max Helskens <max@energieid.be>, Oscar Swyns <oscar@energieid.be>
+License-Expression: MIT
+Keywords: energy,analytics,simulation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.12.15
+Requires-Dist: pandera[polars]>=0.22.1
+Requires-Dist: pvlib>=0.13.0
+Requires-Dist: pydantic>=2.8.2
+Requires-Dist: statsmodels>=0.14.2
+Dynamic: license-file
+
+# OpenEnergyID
+
+Open Source Python library for energy data analytics and simulations
+
+[*more info for developers*](DEVELOPERS.md)

openenergyid-0.1.31.dist-info/RECORD

@@ -0,0 +1,50 @@
+openenergyid/__init__.py,sha256=W7FsfPYrI4DcjTcIucigfC7QR_cSuAcx2ocomFDAYzc,193
+openenergyid/const.py,sha256=2cRYP2rF8YtW4vP1nnsyn-JBgmTEfVO1tS6tqJvC6_M,1458
+openenergyid/enums.py,sha256=jdw4CB1gkisx0re_SesrTEyh_T-UxYp6uieE7iYlHdA,357
+openenergyid/models.py,sha256=G3xXbdNewcXSBr-vyvg4pE6zdaI44OrJIWQxgKjwvkg,6313
+openenergyid/abstractsim/__init__.py,sha256=cl-Eh5y_ZOmacZ0X2YW4TeooqR-oD68Fju3UsH9Yziw,228
+openenergyid/abstractsim/abstract.py,sha256=dhUNoaHiKH-ug2mcHUxDINbKMKh7VWMiAnEhPAUAFiE,3252
+openenergyid/baseload/__init__.py,sha256=nEN4IX5m1_X11paXt11G-G9_iJ-ypwccc9NyQhkwtAQ,437
+openenergyid/baseload/analysis.py,sha256=B7hlTE0EVJeRXLYaBjLfqoV2yrBJ-3h7jdIu0JXLGQg,8410
+openenergyid/baseload/exceptions.py,sha256=uPPQlFmOikp3wuwdVxj3Mx-45TzPkLF86rKMFjT5qB4,250
+openenergyid/baseload/models.py,sha256=wnqZWIenguLWcI8-YKIDf6LuQhtSrNi1m0P7QeEKgMI,996
+openenergyid/capacity/__init__.py,sha256=TVWtOBEA2h_Fy17TRYUBmxXUgd00-CJcbObjFkvRPwQ,221
+openenergyid/capacity/main.py,sha256=vANuP4PVPWdfSnCZdEVvJD01RQHRzNr1sD1pkQeu29s,3675
+openenergyid/capacity/models.py,sha256=aFarIPXzaaKqfEzYDVXG44uDaPTapqNsxKHFpysc9N8,834
+openenergyid/dyntar/__init__.py,sha256=lUrk7ktS7yAqiafRHFoBE0RvFSI9mzDoO37diwLHuBg,495
+openenergyid/dyntar/const.py,sha256=eJJV9VfpHlS9vWV47DWQkS3ICIXWhDmG4cU-ofbZJ3Q,1100
+openenergyid/dyntar/main.py,sha256=6vdJ_jBdoDg5ec0vevMjdBS-p3DDCe3vlvie_Y4unIE,10639
+openenergyid/dyntar/models.py,sha256=jqLY_sGG19eYQX2YG0btxdUNhMOYu6mkguBqDKxJCwI,3099
+openenergyid/elia/__init__.py,sha256=shcLGBpzMm6r8teov7YwGD424f-um58jCiVM2yeHycQ,126
+openenergyid/elia/api.py,sha256=Azs7D7Jr4zlHerD7Ueo4bs2P6ZwJ-0JfeNuvFEFfm3I,2772
+openenergyid/elia/const.py,sha256=b0dQHVSHR4O9sztN7C07vijTGoAURERthP8pKn-k8gc,442
+openenergyid/energysharing/__init__.py,sha256=A4JfrUYf-hBCzhUm0qL1GGlNMvpO8OwXJo80dJxFIvw,274
+openenergyid/energysharing/const.py,sha256=X2zEPtTlsmZ66w6RmLS_h8NmdzObAEi5N6-0yrLN5V4,219
+openenergyid/energysharing/data_formatting.py,sha256=47OAKDmsxgrChrU0jqCCMf1MTXK0qUU9HV2znevTg2o,2613
+openenergyid/energysharing/main.py,sha256=nLXwhA6omGBIjNJzcOlqTmYWF3uuBqqsAO9dsUKf4xo,4492
+openenergyid/energysharing/models.py,sha256=1GPigtXffO1EsZhFkHG0OYwGXK71I9xLC1fD5rHxKwQ,2527
+openenergyid/mvlr/__init__.py,sha256=QNLdUqzE3lg4hkMc5Z47ft7DFydQnw-BF1LaLpLLcaY,471
+openenergyid/mvlr/helpers.py,sha256=Uzbfrj3IpH26wA206KOl0hNucKE-n9guJNC_EROBVKA,983
+openenergyid/mvlr/main.py,sha256=X7H1lzKx3JYOQkHR0R3HLqHvCGa8PuI2CafvYquhEZI,1491
+openenergyid/mvlr/models.py,sha256=3Y_y3A5FmJxDEYT4XGpXiuUTMS8p0umPMeXNFRufGAY,8580
+openenergyid/mvlr/mvlr.py,sha256=zcVWsKDfcS2jdfa-45QPu3YCnhL4p14FHuWpQLLwIL4,18626
+openenergyid/pvsim/__init__.py,sha256=gVNEFsEGEMz9SqhrUCH91GWEgYGCWH6hwbztO6I-OfM,204
+openenergyid/pvsim/abstract.py,sha256=IjYndlmvi9VTnUQ0vCDOLc5wB9d1jWnbq-e5zq0Br88,1688
+openenergyid/pvsim/main.py,sha256=1Pcdkgg3NgSPtESqhqaJdlw8hoBTiwV8XjNtIzWq2go,1796
+openenergyid/pvsim/elia/__init__.py,sha256=XVynbFXNWjDhNDuyJJoe6CYKq5dk46IW21sFqzfrPTE,113
+openenergyid/pvsim/elia/main.py,sha256=hqA1Kbsk3yUgR_Oe_iGzsSnaqSvpjm971G6zljeteac,2900
+openenergyid/pvsim/pvlib/__init__.py,sha256=07PCnTLDi9yPUCXiI2Fa25KXtw2KdS65ICkgZZnjzj4,244
+openenergyid/pvsim/pvlib/main.py,sha256=ZpjYyK60vr45KWld5gZVIS3xi_9Ze_Ggka_2zzIhgAc,3145
+openenergyid/pvsim/pvlib/models.py,sha256=a3xomqRu7WwKQLTTZ57EsCPGfHQsgFL-ZdwOSG_tjXE,7421
+openenergyid/pvsim/pvlib/quickscan.py,sha256=7DoUiUzPd4vZKQxL_Uo6bCz_THJ-G1ul9Ni-eS5N6RM,3874
+openenergyid/pvsim/pvlib/weather.py,sha256=D2xbkTYg3mtt7GDoz0uu_ML2U6ElsQHjbvWs28q-5tM,3022
+openenergyid/sim/__init__.py,sha256=gKslrJwVB80Tm1s27OJyNKiouq0CcAt-vvPXhsu2sec,198
+openenergyid/sim/main.py,sha256=93owbBfC2XXXnmN8Vq7EqcwV-5sI_oYgbonyHs9NPZE,2261
+openenergyid/simeval/__init__.py,sha256=hk-q7enbBpxi3g2D9LMYmw7R1ikdte8mYIvPLVg0aBs,252
+openenergyid/simeval/main.py,sha256=5pucS9mGKKeQmM5P-cyYdw4FQtyBXfil6MU4ppWTpGQ,5895
+openenergyid/simeval/models.py,sha256=xUUr2NEXEUGzo6Jq2X-aDEWyVjINouPZhpHxxmYucNo,4964
+openenergyid-0.1.31.dist-info/licenses/LICENSE,sha256=NgRdcNHwyXVCXZ8sJwoTp0DCowThJ9LWWl4xhbV1IUY,1074
+openenergyid-0.1.31.dist-info/METADATA,sha256=F_nGe1ktTCiWcKb30IMeQxprRbD_X9j_Gz6NWMRPy4c,1216
+openenergyid-0.1.31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+openenergyid-0.1.31.dist-info/top_level.txt,sha256=vf3DmJCXgD_lJjSPFktonUJJT6vEg6KIPCKMPfCWCFI,13
+openenergyid-0.1.31.dist-info/RECORD,,

openenergyid-0.1.31.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

openenergyid-0.1.31.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 EnergieID cvba-so
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

openenergyid-0.1.31.dist-info/top_level.txt

@@ -0,0 +1 @@
+openenergyid