Creation of Reporter class

flexmeasures/data/models/reporting/__init__.py

@@ -25,10 +25,6 @@ class Reporter(DataGeneratorMixin):
     reporter_config_raw: Optional[dict] = None
     schema = ReporterConfigSchema
     data: Dict[str, Union[tb.BeliefsDataFrame, pd.DataFrame]] = None
-    start: datetime = None
-    end: datetime = None
-    input_resolution: timedelta = None
-    belief_time: datetime = None
 
     def __init__(
         self, sensor: Sensor, reporter_config_raw: Optional[dict] = None
@@ -48,7 +44,13 @@ def __init__(
 
         self.reporter_config_raw = reporter_config_raw
 
-    def fetch_data(self):
+    def fetch_data(
+        self,
+        start: datetime,
+        end: datetime,
+        input_resolution: timedelta = None,
+        belief_time: datetime = None,
+    ):
         """
         Fetches the time_beliefs from the database
         """
@@ -57,10 +59,10 @@ def fetch_data(self):
         for tb_query in self.tb_query_config:
             _tb_query = tb_query.copy()
             # using start / end instead of event_starts_after/event_ends_before when not defined
-            event_starts_after = _tb_query.pop("event_starts_after", self.start)
-            event_ends_before = _tb_query.pop("event_ends_before", self.end)
-            resolution = _tb_query.pop("resolution", self.input_resolution)
-            belief_time = _tb_query.pop("belief_time", self.belief_time)
+            event_starts_after = _tb_query.pop("event_starts_after", start)
+            event_ends_before = _tb_query.pop("event_ends_before", end)
+            resolution = _tb_query.pop("resolution", input_resolution)
+            belief_time = _tb_query.pop("belief_time", belief_time)
 
             sensor: Sensor = _tb_query.pop("sensor", None)
             alias: str = _tb_query.pop("alias", None)
@@ -89,9 +91,8 @@ def update_attribute(self, attribute, default):
 
     def compute(
         self,
-        *args,
-        start: datetime = None,
-        end: datetime = None,
+        start: datetime,
+        end: datetime,
         input_resolution: timedelta = None,
         belief_time: datetime = None,
         **kwargs,
@@ -108,17 +109,11 @@ def compute(
         if self.reporter_config is None:
             self.deserialize_config()
 
-        # if provided, update the class attributes
-        self.update_attribute("start", start)
-        self.update_attribute("end", end)
-        self.update_attribute("input_resolution", input_resolution)
-        self.update_attribute("belief_time", belief_time)
-
         # fetch data
-        self.fetch_data()
+        self.fetch_data(start, end, input_resolution, belief_time)
 
         # Result
-        result = self._compute()
+        result = self._compute(start, end, input_resolution, belief_time)
 
         # checking that the event_resolution of the output BeliefDataFrame is equal to the one of the output sensor
         assert self.sensor.event_resolution == result.event_resolution
@@ -128,7 +123,13 @@ def compute(
 
         return result
 
-    def _compute(self) -> tb.BeliefsDataFrame:
+    def _compute(
+        self,
+        start: datetime,
+        end: datetime,
+        input_resolution: timedelta = None,
+        belief_time: datetime = None,
+    ) -> tb.BeliefsDataFrame:
         """
         Overwrite with the actual computation of your report.
 
@@ -137,31 +138,6 @@ def _compute(self) -> tb.BeliefsDataFrame:
         raise NotImplementedError()
 
     def deserialize_config(self):
-        """
-        Check all configurations we have, throwing either ValidationErrors or ValueErrors.
-        Other code can decide if/how to handle those.
-        """
-        self.deserialize_reporter_config()
-        self.deserialize_timing_config()
-
-    def deserialize_timing_config(self):
-        """
-        Check if the timing of the report is valid.
-
-        Raises ValueErrors.
-        """
-
-        for tb_query in self.tb_query_config:
-            start = tb_query.get("event_starts_after", self.start)
-            end = tb_query.get("event_ends_before ", self.end)
-
-            if (
-                start is not None and end is not None
-            ):  # not testing when start or end are missing
-                if end < start:
-                    raise ValueError(f"Start {start} cannot be after end {end}.")
-
-    def deserialize_reporter_config(self):
         """
         Validate the report config against a Marshmallow Schema.
         Ideas:
@@ -178,7 +154,3 @@ def deserialize_reporter_config(self):
         self.tb_query_config = self.reporter_config.get(
             "tb_query_config"
         )  # extracting TimeBelief query configuration parameters
-        self.start = self.reporter_config.get("start")
-        self.end = self.reporter_config.get("end")
-        self.input_resolution = self.reporter_config.get("input_resolution")
-        self.belief_time = self.reporter_config.get("belief_time")

flexmeasures/data/models/reporting/pandas_reporter.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from typing import Any
+from datetime import datetime, timedelta
 
 from flask import current_app
 import timely_beliefs as tb
@@ -20,15 +21,21 @@ class PandasReporter(Reporter):
     transformations: list[dict[str, Any]] = None
     final_df_output: str = None
 
-    def deserialize_reporter_config(self):
-        # call super class deserialize_reporter_config
-        super().deserialize_reporter_config()
+    def deserialize_config(self):
+        # call super class deserialize_config
+        super().deserialize_config()
 
         # extract PandasReporter specific fields
         self.transformations = self.reporter_config.get("transformations")
         self.final_df_output = self.reporter_config.get("final_df_output")
 
-    def _compute(self) -> tb.BeliefsDataFrame:
+    def _compute(
+        self,
+        start: datetime,
+        end: datetime,
+        input_resolution: timedelta = None,
+        belief_time: datetime = None,
+    ) -> tb.BeliefsDataFrame:
         """
         This method applies the transformations and outputs the dataframe
         defined in `final_df_output` field of the report_config.

flexmeasures/data/models/reporting/tests/test_pandas_reporter.py

@@ -1,5 +1,6 @@
 import pytest
 from datetime import datetime, timedelta
+
 from pytz import utc
 
 import pandas as pd
@@ -86,8 +87,6 @@ def test_reporter(setup_dummy_data):
     s1, s2, reporter_sensor = setup_dummy_data
 
     reporter_config_raw = dict(
-        start="2023-04-10T00:00:00 00:00",
-        end="2023-04-10T10:00:00 00:00",
         tb_query_config=[dict(sensor=s1.id), dict(sensor=s2.id)],
         transformations=[
             dict(
@@ -120,7 +119,9 @@ def test_reporter(setup_dummy_data):
 
     reporter = PandasReporter(reporter_sensor, reporter_config_raw=reporter_config_raw)
 
-    report1 = reporter.compute()
+    start = datetime(2023, 4, 10, tzinfo=utc)
+    end = datetime(2023, 4, 10, 10, tzinfo=utc)
+    report1 = reporter.compute(start, end)
 
     assert len(report1) == 5
     assert str(report1.index[0]) == "2023-04-10 00:00:00+00:00"
@@ -129,12 +130,10 @@ def test_reporter(setup_dummy_data):
     )  # check that the output sensor is effectively assigned.
 
     # check that calling compute with different parameters changes the result
-    report3 = reporter.compute(start=datetime(2023, 4, 10, 3, tzinfo=utc))
+    report3 = reporter.compute(start=datetime(2023, 4, 10, 3, tzinfo=utc), end=end)
     assert len(report3) == 4
     assert str(report3.index[0]) == "2023-04-10 02:00:00+00:00"
 
-    # TODO: resample with BeliefDataFrame specific method (resample_event)
-
 
 def test_reporter_repeated(setup_dummy_data):
     """check that calling compute doesn't change the result"""
@@ -184,7 +183,10 @@ def test_reporter_repeated(setup_dummy_data):
     )
 
     reporter = PandasReporter(reporter_sensor, reporter_config_raw=reporter_config_raw)
+    start = datetime(2023, 4, 10, tzinfo=utc)
+    end = datetime(2023, 4, 10, 10, tzinfo=utc)
+
+    report1 = reporter.compute(start=start, end=end)
+    report2 = reporter.compute(start=start, end=end)
 
-    report1 = reporter.compute()
-    report2 = reporter.compute()
     pd.testing.assert_series_equal(report1, report2)

flexmeasures/data/models/reporting/tests/test_tibber_reporter.py

@@ -84,7 +84,6 @@ def __init__(self, sensor) -> None:
 
         # create the PandasReporter reporter config
         reporter_config = dict(
-            input_resolution="PT1H",
             tb_query_config=[
                 dict(sensor=EnergyTax.id, alias="energy_tax_df"),
                 dict(sensor=VAT.id),
@@ -251,6 +250,7 @@ def test_tibber_reporter(tibber_test_data):
     result = tibber_reporter.compute(
         start=datetime(2023, 4, 13, tzinfo=utc),
         end=datetime(2023, 4, 14, tzinfo=utc),
+        input_resolution=timedelta(hours=1),
     )
 
     # check that we got a result for 24 hours

flexmeasures/data/schemas/reporting/__init__.py

@@ -41,17 +41,10 @@ class ReporterConfigSchema(Schema):
     """
     This schema is used to validate Reporter class configurations (reporter_config).
     Inherit from this to extend this schema with your own parameters.
-
-    If the fields event_starts_after or event_ends_before are not present in `tb_query_config`
-    they will look up in the fields `start` and `end`
     """
 
     tb_query_config = fields.List(
         fields.Nested(TimeBeliefQueryConfigSchema()),
         required=True,
         validator=validate.Length(min=1),
     )
-    start = AwareDateTimeField()
-    end = AwareDateTimeField()
-    input_resolution = DurationField()
-    belief_time = AwareDateTimeField()

flexmeasures/data/schemas/tests/test_reporting.py

@@ -36,7 +36,7 @@ def setup_dummy_sensors(db, app):
 
 
 @pytest.mark.parametrize(
-    "report_config, is_valid",
+    "reporter_config, is_valid",
     [
         (
             {  # this checks that the final_df_output dataframe is actually generated at some point of the processing pipeline
@@ -125,12 +125,14 @@ def setup_dummy_sensors(db, app):
         ),
     ],
 )
-def test_pandas_reporter(report_config, is_valid, db, app, setup_dummy_sensors):
+def test_pandas_reporter_schema(
+    reporter_config, is_valid, db, app, setup_dummy_sensors
+):
 
     schema = PandasReporterConfigSchema()
 
     if is_valid:
-        schema.load(report_config)
+        schema.load(reporter_config)
     else:
         with pytest.raises(ValidationError):
-            schema.load(report_config)
+            schema.load(reporter_config)