feat[DEI-263]: year filter added for multi-year aggregation

Author: wschoonveld

decoimpact/business/entities/rules/time_aggregation_rule.py

@@ -11,7 +11,7 @@
     TimeAggregationRule
 """
 
-from typing import List
+from typing import List, Optional
 
 import numpy as _np
 import xarray as _xr
@@ -35,18 +35,32 @@ def __init__(
         name: str,
         input_variable_names: List[str],
         operation_type: TimeOperationType,
+        start_year: Optional[int] = None,
+        end_year: Optional[int] = None,
     ):
         super().__init__(name, input_variable_names)
         self._settings = TimeOperationSettings({"month": "ME", "year": "YE"})
         self._settings.percentile_value = 0
         self._settings.operation_type = operation_type
         self._settings.time_scale = "year"
+        self._start_year = start_year
+        self._end_year = end_year
 
     @property
     def settings(self):
         """Time operation settings"""
         return self._settings
 
+    @property
+    def start_year(self) -> Optional[int]:
+        """Start year for the aggregation (inclusive)"""
+        return self._start_year
+
+    @property
+    def end_year(self) -> Optional[int]:
+        """End year for the aggregation (inclusive)"""
+        return self._end_year
+
     def validate(self, logger: ILogger) -> bool:
         """Validates if the rule is valid
 
@@ -86,6 +100,10 @@ def execute(self, value_array: _xr.DataArray, logger: ILogger) -> _xr.DataArray:
         result = _xr.DataArray(data=_np.empty(0), dims=("time",), coords={"time": []})
         # perform aggregations in case of multi-year monthly average
         if TimeOperationType.MULTI_YEAR_MONTHLY_AVERAGE == settings.operation_type:
+            start = str(self._start_year) if self._start_year is not None else None
+            end = str(self._end_year) if self._end_year is not None else None
+            slice_obj = slice(start, end)
+            value_array = value_array.sel({time_dim_name: slice_obj})
             grouped_values = value_array.groupby(f"{time_dim_name}.month")
             result = self._perform_grouping_operation(
                 grouped_values, settings.operation_type, time_dim_name

decoimpact/data/api/i_time_aggregation_rule_data.py

@@ -15,6 +15,8 @@
 
 from abc import ABC, abstractmethod
 
+from pyparsing import Optional
+
 from decoimpact.data.api.i_rule_data import IRuleData
 from decoimpact.data.api.time_operation_type import TimeOperationType
 
@@ -41,3 +43,13 @@ def percentile_value(self) -> float:
     @abstractmethod
     def time_scale(self) -> str:
         """Time scale"""
+
+    @property
+    @abstractmethod
+    def start_year(self) -> Optional[int]:
+        """Start year for the aggregation (inclusive)"""
+
+    @property
+    @abstractmethod
+    def end_year(self) -> Optional[int]:
+        """End year for the aggregation (inclusive)"""

tests/business/entities/rules/test_time_aggregation_rule.py

@@ -438,7 +438,7 @@ def test_execute_value_array_aggregate_time_months_percentile():
     )
 
 
-def test_execute_value_array_aggregate_time_multi_yearly_month_average():
+def test_multi_year_monthly_average():
     """Aggregate input_variable_names of a TimeAggregationRule (average, months)"""
 
     # create test set
@@ -463,6 +463,34 @@ def test_execute_value_array_aggregate_time_multi_yearly_month_average():
     )
 
 
+def test_multi_yearly_month_average_with_year_range():
+    """Aggregate input_variable_names of a TimeAggregationRule (average, months) with year range"""
+
+    # create test set
+    logger = Mock(ILogger)
+    rule = TimeAggregationRule(
+        name="test",
+        input_variable_names=["foo"],
+        operation_type=TimeOperationType.MULTI_YEAR_MONTHLY_AVERAGE,
+        start_year=2020,
+        end_year=2020,
+    )
+    rule.settings.time_scale = "month"
+
+    time_aggregation = rule.execute(value_array_multi_year_monthly, logger)
+
+    # result_data = [0.15, 0.45, 0.3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+    result_data = [0.1, 0.7, 0.2, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+    result_array = _xr.DataArray(
+        result_data, coords=[result_time_multi_year_monthly], dims=["time_monthly"]
+    )
+
+    # Assert
+    assert (
+        _xr.testing.assert_allclose(time_aggregation, result_array, atol=1e-11) is None
+    )
+
+
 def test_operation_type_not_implemented():
     """Test that the time aggregation rule gives an error
     if no operation_type is given"""