feat: Raise error for unknown keywords

hydrolib/core/dflowfm/ini/models.py

@@ -25,7 +25,7 @@
     INISerializerConfig,
     write_ini,
 )
-from .util import make_list_validator
+from .util import UnknownKeywordErrorManager, make_list_validator
 
 logger = logging.getLogger(__name__)
 
@@ -45,8 +45,9 @@ class INIBasedModel(BaseModel, ABC):
             descriptions for all data fields.
     """
 
-    _header: str
+    _header: str = ""
     _file_path_style_converter = FilePathStyleConverter()
+    _unknown_keyword_error_manager = UnknownKeywordErrorManager()
     _scientific_notation_regex = compile(
         r"([\d.]+)([dD])([+-]?\d{1,3})"
     )  # matches a float: 1d9, 1D-3, 1.D+4, etc.
@@ -55,6 +56,15 @@ class Config:
         extra = Extra.ignore
         arbitrary_types_allowed = False
 
+    def __init__(self, **data):
+        super().__init__(**data)
+        self._unknown_keyword_error_manager.raise_error_for_unknown_keywords(
+            data,
+            self._header,
+            self.__fields__,
+            self._exclude_fields(),
+        )
+
     @classmethod
     def _supports_comments(cls):
         return True

hydrolib/core/dflowfm/ini/util.py

@@ -3,8 +3,9 @@
 from datetime import datetime
 from enum import Enum
 from operator import eq
-from typing import Any, Callable, Dict, List, Optional, Type
+from typing import Any, Callable, Dict, List, Optional, Set, Type
 
+from pydantic import Extra
 from pydantic.v1.class_validators import root_validator, validator
 from pydantic.v1.fields import ModelField
 from pydantic.v1.main import BaseModel
@@ -622,3 +623,48 @@ def rename_keys_for_backwards_compatibility(
                 break
 
     return values
+
+
+class UnknownKeywordErrorManager:
+    """
+    Error manager for unknown keys.
+    Detects unknown keys and manages the Error to the user.
+    """
+
+    def raise_error_for_unknown_keywords(
+        self,
+        data: Dict[str, Any],
+        section_header: str,
+        fields: Dict[str, Any],
+        excluded_fields: Set,
+    ):
+        """
+        Notify the user of unknown keywords.
+
+        Args:
+            data (Dict[str, Any])   : Input data containing all set properties which are checked on unknown keywords.
+            section_header (str)    : Header of the section in which unknown keys might be detected.
+            fields (Dict[str, Any]) : Known fields of the section.
+            excluded_fields (Set)   : Fields which should be excluded from the check for unknown keywords.
+        """
+        unknown_keywords = self._get_all_unknown_keywords(data, fields, excluded_fields)
+
+        if len(unknown_keywords) == 0:
+            return
+
+        raise ValueError(f"Unknown keywords are detected in section: '{section_header}', '{unknown_keywords}'")
+
+    def _get_all_unknown_keywords(
+        self, data: Dict[str, Any], fields: Dict[str, Any], excluded_fields: Set
+    ) -> List[str]:
+        list_of_unknown_keywords = []
+        for name, _ in data.items():
+            if self._is_unknown_keyword(name, fields, excluded_fields):
+                list_of_unknown_keywords.append(name)
+
+        return list_of_unknown_keywords
+
+    def _is_unknown_keyword(
+        self, name: str, fields: Dict[str, Any], excluded_fields: Set
+    ):
+        return name not in fields and name not in excluded_fields

tests/dflowfm/ini/test_util.py

@@ -9,6 +9,7 @@
 from hydrolib.core.dflowfm.ini.util import (
     LocationValidationConfiguration,
     LocationValidationFieldNames,
+    UnknownKeywordErrorManager,
     get_from_subclass_defaults,
     get_type_based_on_subclass_default_value,
     rename_keys_for_backwards_compatibility,
@@ -356,3 +357,27 @@ class WithoutDefaultProperty(BaseClass):
 
 class GrandChildWithDefaultProperty(WithoutDefaultProperty):
     name: Literal["GrandChildWithDefaultProperty"] = "GrandChildWithDefaultProperty"
+
+
+class TestUnknownKeywordErrorManager:
+
+    def test_unknown_keywords_given_when_notify_unknown_keywords_gives_error_with_unknown_keywords(
+        self
+    ):
+        section_header = "section header"
+        fields = {}
+        excluded_fields = set()
+        name = "keyname"
+        second_name = "second_other"
+
+        ukem = UnknownKeywordErrorManager()
+        data = {name: 1, second_name: 2}
+
+        expected_message = f"Unknown keywords are detected in section: '{section_header}', '{[name, second_name]}'"
+
+        with pytest.raises(ValueError) as exc_err:
+            ukem.raise_error_for_unknown_keywords(
+                data, section_header, fields, excluded_fields
+            )
+
+        assert expected_message in str(exc_err.value)

tests/dflowfm/test_mdu.py

@@ -1,4 +1,8 @@
 from pathlib import Path
+from unittest import mock
+from unittest.mock import patch
+
+from pydantic.v1.config import Extra
 
 from hydrolib.core.basemodel import DiskOnlyFileModel
 from hydrolib.core.dflowfm.mdu.models import (
@@ -388,3 +392,115 @@ def test_loading_fmmodel_model_with_both_ini_and_xyn_obsfiles(self):
             assert actual_point.x == expected_point.x
             assert actual_point.y == expected_point.y
             assert actual_point.name == expected_point.name
+
+    def test_mdu_unknown_keywords_loading_gives_message_for_missing_keyword(
+        self, tmp_path, capsys
+    ):
+        tmp_mdu = """
+        [General]
+        fileVersion           = 1.09          
+        fileType              = modelDef      
+        program               = D-Flow FM     
+        version               = 1.2.100.66357 
+        autoStart             = 0             
+        pathsRelativeToParent = 0             
+        unknownkey            = something
+        """
+
+        tmp_mdu_path = tmp_path / "tmp.mdu"
+        tmp_mdu_path.write_text(tmp_mdu)
+
+        with patch(
+            "hydrolib.core.dflowfm.ini.models.INIBasedModel.Config"
+        ) as mock_config:
+            mock_config.extra = Extra.ignore
+
+            FMModel(filepath=tmp_mdu_path)
+            captured = capsys.readouterr()
+
+            section = "General"
+            name = "unknownkey"
+
+            assert (
+                f"Unknown keywords are detected in '{section}', these keywords will be dropped:"
+                in captured.out
+            )
+            assert name in captured.out
+
+    def test_mdu_unknown_keywords_loading_gives_message_for_missing_keyword2(
+        self, tmp_path, capsys
+    ):
+        tmp_mdu = """
+        [General]
+        fileVersion           = 1.09          
+        fileType              = modelDef      
+        program               = D-Flow FM     
+        version               = 1.2.100.66357 
+        autoStart             = 0             
+        pathsRelativeToParent = 0             
+        unknownkey            = something
+        """
+
+        tmp_mdu_path = tmp_path / "tmp.mdu"
+        tmp_mdu_path.write_text(tmp_mdu)
+
+        with patch(
+            "hydrolib.core.dflowfm.ini.models.INIBasedModel.Config"
+        ) as mock_config:
+            mock_config.extra = Extra.allow
+
+            FMModel(filepath=tmp_mdu_path)
+            captured = capsys.readouterr()
+
+            section = "General"
+            name = "unknownkey"
+
+            assert (
+                f"Unknown keywords are detected in '{section}', these keywords will be kept in memory but will have no validation:"
+                in captured.out
+            )
+            assert name in captured.out
+
+    def test_mdu_unknown_keywords_loading_does_not_give_message_on_exclude_fields(
+        self, tmp_path, capsys
+    ):
+        tmp_mdu = """
+        [General]
+        fileVersion           = 1.09          
+        fileType              = modelDef      
+        program               = D-Flow FM     
+        version               = 1.2.100.66357 
+        autoStart             = 0             
+        pathsRelativeToParent = 0             
+        unknownkey            = something
+        """
+
+        tmp_mdu_path = tmp_path / "tmp.mdu"
+        tmp_mdu_path.write_text(tmp_mdu)
+
+        FMModel(filepath=tmp_mdu_path)
+        captured = capsys.readouterr()
+
+        excluded_fields = ["comments", "datablock", "_header"]
+        for excluded_field in excluded_fields:
+            assert excluded_field not in captured.out
+
+    def test_mdu_unknown_keywords_allow_extra_setting_field_gives_message(self, capsys):
+        model = FMModel()
+        config_extra_setting = (
+            model.general.Config.extra
+        )  # Save the Config.extra to revert back to original setting after the test.
+
+        model.general.Config.extra = Extra.allow
+        model.general.unknown = "something"
+        captured = capsys.readouterr()
+
+        model.general.Config.extra = config_extra_setting  # Revert the Config.extra to the original setting, if this is not done it can affect other tests.
+
+        section = "General"
+        name = "unknown"
+
+        assert (
+            f"Unknown keyword detected in '{section}', '{name}', keyword will be kept in memory but will have no validation."
+            in captured.out
+        )