T3D header not correct

hydrolib/core/io/bc/models.py

@@ -9,7 +9,6 @@
 
 """
 import logging
-from ast import For
 from enum import Enum
 from pathlib import Path
 from typing import Callable, Dict, List, Literal, Optional, Set, Union
@@ -30,6 +29,7 @@
 from hydrolib.core.io.ini.util import (
     get_enum_validator,
     get_from_subclass_defaults,
+    get_key_renaming_root_validator,
     get_split_string_on_delimiter_validator,
     make_list_validator,
 )
@@ -100,85 +100,6 @@ def _to_properties(self):
             yield Property(key="vertPositionIndex", value=self.vertpositionindex)
 
 
-class ForcingBackwardsCompatibilityHelper:
-    """Class to add backwards compatibility for certain keywords in the .bc file."""
-
-    @staticmethod
-    def add_backwards_compatibility_for_timeinterpolation(values: Dict) -> Dict:
-        """Add backwards compatibility for older timeInterpolation keywords."""
-
-        timeinterpolation_keyword = "timeinterpolation"
-
-        if values.get(timeinterpolation_keyword) is not None:
-            return values
-
-        old_keyword = "time_interpolation"
-        if values.get(old_keyword) is not None:
-            values[timeinterpolation_keyword] = values.get(old_keyword)
-
-        return values
-
-    @staticmethod
-    def add_backwards_compatibility_for_vertpositions(values: Dict) -> Dict:
-        """Add backwards compatibility for older vertPositions keywords."""
-
-        vertpositions_keyword = "vertpositions"
-
-        if values.get(vertpositions_keyword) is not None:
-            return values
-
-        old_keyword = "vertical_position_specification"
-        if values.get(old_keyword) is not None:
-            values[vertpositions_keyword] = values.get(old_keyword)
-
-        return values
-
-    @staticmethod
-    def add_backwards_compatibility_for_vertinterpolation(values: Dict) -> Dict:
-        """Add backwards compatibility for older vertInterpolation keywords."""
-
-        vertinterpolation_keyword = "vertinterpolation"
-
-        if values.get(vertinterpolation_keyword) is not None:
-            return values
-
-        old_keyword = "vertical_interpolation"
-        if values.get(old_keyword) is not None:
-            values[vertinterpolation_keyword] = values.get(old_keyword)
-
-        return values
-
-    @staticmethod
-    def add_backwards_compatibility_for_vertpositiontype(values: Dict) -> Dict:
-        """Add backwards compatibility for older vertPositionType keywords."""
-
-        vertpositiontype_keyword = "vertpositiontype"
-
-        if values.get(vertpositiontype_keyword) is not None:
-            return values
-
-        old_keyword = "vertical_position_type"
-        if values.get(old_keyword) is not None:
-            values[vertpositiontype_keyword] = values.get(old_keyword)
-
-        return values
-
-    @staticmethod
-    def add_backwards_compatibility_for_vertpositionindex(values: Dict) -> Dict:
-        """Add backwards compatibility for older vertPositionIndex keywords."""
-
-        vertpositionindex_keyword = "vertpositionindex"
-
-        if values.get(vertpositionindex_keyword) is not None:
-            return values
-
-        old_keyword = "vertical_position"
-        if values.get(old_keyword) is not None:
-            values[vertpositionindex_keyword] = values.get(old_keyword)
-
-        return values
-
-
 class ForcingBase(DataBlockINIBasedModel):
     """
     The base class of a single [Forcing] block in a .bc forcings file.
@@ -307,13 +228,11 @@ class TimeSeries(ForcingBase):
         "timeinterpolation", enum=TimeInterpolation
     )
 
-    @root_validator(pre=True)
-    def add_backwards_compatibility_for_timeinterpolation(cls, values: Dict) -> Dict:
-        ForcingBackwardsCompatibilityHelper.add_backwards_compatibility_for_timeinterpolation(
-            values
-        )
-
-        return values
+    _key_renaming_root_validator = get_key_renaming_root_validator(
+        {
+            "timeinterpolation": ["time_interpolation"],
+        }
+    )
 
 
 class Harmonic(ForcingBase):
@@ -373,6 +292,16 @@ class T3D(ForcingBase):
     )
     """TimeInterpolation: The type of time interpolation. Defaults to linear."""
 
+    _key_renaming_root_validator = get_key_renaming_root_validator(
+        {
+            "timeinterpolation": ["time_interpolation"],
+            "vertpositions": ["vertical_position_specification"],
+            "vertinterpolation": ["vertical_interpolation"],
+            "vertpositiontype": ["vertical_position_type"],
+            "vertpositionindex": ["vertical_position"],
+        }
+    )
+
     _split_to_list = get_split_string_on_delimiter_validator(
         "vertpositions",
     )
@@ -388,36 +317,7 @@ class T3D(ForcingBase):
     )
 
     @root_validator(pre=True)
-    def _add_support_for_keywords_with_spaces_and_validate_quantityunitpair(
-        cls, values: Dict
-    ) -> Dict:
-        values = cls._add_support_for_keywords_with_spaces(values)
-        values = cls._validate_quantityunitpair(values)
-
-        return values
-
-    @classmethod
-    def _add_support_for_keywords_with_spaces(cls, values: Dict) -> Dict:
-        ForcingBackwardsCompatibilityHelper.add_backwards_compatibility_for_timeinterpolation(
-            values
-        )
-        ForcingBackwardsCompatibilityHelper.add_backwards_compatibility_for_vertinterpolation(
-            values
-        )
-        ForcingBackwardsCompatibilityHelper.add_backwards_compatibility_for_vertpositionindex(
-            values
-        )
-        ForcingBackwardsCompatibilityHelper.add_backwards_compatibility_for_vertpositions(
-            values
-        )
-        ForcingBackwardsCompatibilityHelper.add_backwards_compatibility_for_vertpositiontype(
-            values
-        )
-
-        return values
-
-    @classmethod
-    def _validate_quantityunitpair(cls, values: Dict) -> Dict:
+    def _validate_quantityunitpairs(cls, values: Dict) -> Dict:
         super()._validate_quantityunitpair(values)
 
         quantityunitpairs = values["quantityunitpair"]
@@ -484,7 +384,7 @@ def _validate_verticalpositionindexes_and_update_quantityunitpairs(
         quantityunitpairs: List[QuantityUnitPair],
     ) -> None:
         if verticalpositionindexes is None:
-            raise ValueError("vertpositionindex is not provided")
+            raise ValueError("vertPositionIndex is not provided")
 
         if len(verticalpositionindexes) != len(quantityunitpairs) - 1:
             raise ValueError(

hydrolib/core/io/ini/util.py

@@ -462,3 +462,28 @@ def is_valid_coordinates_with_num_coordinates_specification() -> bool:
         raise ValueError(error)
 
     return root_validator(allow_reuse=True)(validate_location_specification)
+
+
+def get_key_renaming_root_validator(keys_to_rename: Dict[str, List[str]]):
+    """
+    Gets a root validator that renames the provided keys to support backwards compatibility.
+
+    Args:
+            keys_to_rename Dict[str, List[str]]: Dictionary of keys and a list of old keys that
+            should be converted to the current key.
+    """
+
+    def rename_keys(cls, values: Dict) -> Dict:
+        for current_keyword, old_keywords in keys_to_rename.items():
+            if values.get(current_keyword) is not None:
+                continue
+
+            for old_keyword in old_keywords:
+                if values.get(old_keyword) is not None:
+                    values[current_keyword] = values.get(old_keyword)
+                    del values[old_keyword]
+                    break
+
+        return values
+
+    return root_validator(allow_reuse=True, pre=True)(rename_keys)

tests/io/ini/test_util.py

@@ -1,12 +1,14 @@
 from typing import Dict, List, Optional
 
 import pytest
+from pydantic import Extra
 from pydantic.error_wrappers import ValidationError
 
 from hydrolib.core.basemodel import BaseModel
 from hydrolib.core.io.ini.util import (
     LocationValidationConfiguration,
     LocationValidationFieldNames,
+    get_key_renaming_root_validator,
     get_location_specification_rootvalidator,
 )
 
@@ -198,3 +200,42 @@ def test_correct_1d_fields_locationtype_is_added(
             values
         )
         assert validated_values == expected_values
+
+
+class TestGetKeyRenamingRootValidator:
+    class DummyModel(BaseModel):
+        """Dummy model to test the validation of the location specification."""
+
+        randomproperty: str
+
+        validator = get_key_renaming_root_validator(
+            {
+                "randomproperty": [
+                    "randomProperty",
+                    "random_property",
+                    "oldRandomProperty",
+                ],
+            }
+        )
+
+        class Config:
+            extra = Extra.allow
+
+    @pytest.mark.parametrize(
+        "old_key", ["randomProperty", "random_property", "oldRandomProperty"]
+    )
+    def test_old_keys_are_correctly_renamed_to_current_keyword(self, old_key: str):
+        values = {old_key: "randomString"}
+
+        model = TestGetKeyRenamingRootValidator.DummyModel(**values)
+
+        assert model.randomproperty == "randomString"
+
+    def test_unknown_key_still_raises_error(self):
+        values = {"randomKeyThatNeverExisted": "randomString"}
+
+        with pytest.raises(ValidationError) as error:
+            TestGetKeyRenamingRootValidator.DummyModel(**values)
+
+        expected_message = "field required"
+        assert expected_message in str(error.value)

tests/io/test_bc.py

@@ -10,7 +10,6 @@
     Astronomic,
     AstronomicCorrection,
     Constant,
-    ForcingBackwardsCompatibilityHelper,
     ForcingBase,
     ForcingModel,
     Harmonic,
@@ -580,7 +579,7 @@ def test_load_forcing_model(self):
             [120.0, 7.0, 8.0, 9.0],
         ]
 
-    def test_load_t3d_model_with_old_keyword_that_contain_spaces(self):
+    def test_load_t3d_model_with_old_keyword_that_contains_spaces(self):
         bc_file = Path(test_reference_dir / "bc" / TEST_BC_FILE_KEYWORDS_WITH_SPACES)
         forcingmodel = ForcingModel(bc_file)
 
@@ -633,73 +632,6 @@ def _validate_that_correct_quantityunitpairs_are_created(
             )
 
 
-class TestForcingBackwardsCompatibilityHelper:
-    def test_old_timeinterpolation_keyword_gets_converted_to_current_keyword(self):
-        old_keyword = "time_interpolation"
-        data = TimeInterpolation.block_from
-
-        values = {old_keyword: data}
-
-        values = ForcingBackwardsCompatibilityHelper.add_backwards_compatibility_for_timeinterpolation(
-            values
-        )
-
-        current_keyword = "timeinterpolation"
-        assert values[current_keyword] == data
-
-    def test_old_vertpositions_keyword_gets_converted_to_current_keyword(self):
-        old_keyword = "vertical_position_specification"
-        data = [1, 2, 3]
-
-        values = {old_keyword: data}
-
-        values = ForcingBackwardsCompatibilityHelper.add_backwards_compatibility_for_vertpositions(
-            values
-        )
-
-        current_keyword = "vertpositions"
-        assert values[current_keyword] == data
-
-    def test_old_vertinterpolation_keyword_gets_converted_to_current_keyword(self):
-        old_keyword = "vertical_interpolation"
-        data = VerticalInterpolation.block
-
-        values = {old_keyword: data}
-
-        values = ForcingBackwardsCompatibilityHelper.add_backwards_compatibility_for_vertinterpolation(
-            values
-        )
-
-        current_keyword = "vertinterpolation"
-        assert values[current_keyword] == data
-
-    def test_old_vertpositiontype_keyword_gets_converted_to_current_keyword(self):
-        old_keyword = "vertical_position_type"
-        data = VerticalPositionType.percentage_bed
-
-        values = {old_keyword: data}
-
-        values = ForcingBackwardsCompatibilityHelper.add_backwards_compatibility_for_vertpositiontype(
-            values
-        )
-
-        current_keyword = "vertpositiontype"
-        assert values[current_keyword] == data
-
-    def test_old_vertpositionindex_keyword_gets_converted_to_current_keyword(self):
-        old_keyword = "vertical_position"
-        data = [1, 2, 3]
-
-        values = {old_keyword: data}
-
-        values = ForcingBackwardsCompatibilityHelper.add_backwards_compatibility_for_vertpositionindex(
-            values
-        )
-
-        current_keyword = "vertpositionindex"
-        assert values[current_keyword] == data
-
-
 def _create_time_series_values():
     return dict(
         name="boundary_timeseries",