fmu-settings 0.4.0__tar.gz → 0.5.1__tar.gz

{fmu_settings-0.4.0 → fmu_settings-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu-settings
-Version: 0.4.0
+Version: 0.5.1
 Summary: A library for managing FMU settings
 Author-email: Equinor <fg-fmu_atlas@equinor.com>
 License: GPL-3.0

{fmu_settings-0.4.0 → fmu_settings-0.5.1}/src/fmu/settings/_global_config.py

@@ -3,6 +3,8 @@
 from pathlib import Path
 from typing import Final
 
+from pydantic import ValidationError
+
 from fmu.config.utilities import yaml_load
 from fmu.datamodels.fmu_results.global_configuration import GlobalConfiguration
 
@@ -10,6 +12,15 @@ from ._logging import null_logger
 
 logger: Final = null_logger(__name__)
 
+
+class InvalidGlobalConfigurationError(ValueError):
+    """Raised when a GlobalConfiguration contains invalid or disallowed content.
+
+    This includes Drogon test data or other disallowed masterdata.
+    This error is only raised when strict validation is enabled.
+    """
+
+
 # These should all be normalized to lower case.
 INVALID_NAMES: Final[tuple[str, ...]] = (
     "drogon",
@@ -47,53 +58,66 @@ def validate_global_configuration_strictly(cfg: GlobalConfiguration) -> None:  #
         cfg: A GlobalConfiguration instance to be validated
 
     Raises:
-        ValueError: If some value in the GlobalConfiguration is invalid or not allowed
+        InvalidGlobalConfigurationError: If some value in the GlobalConfiguration
+            is invalid or not allowed
     """
     # Check model and access
     if cfg.model.name.lower() in INVALID_NAMES:
-        raise ValueError(f"Invalid name in 'model': {cfg.model.name}")
+        raise InvalidGlobalConfigurationError(
+            f"Invalid name in 'model': {cfg.model.name}"
+        )
     if cfg.access.asset.name.lower() in INVALID_NAMES:
-        raise ValueError(f"Invalid name in 'access.asset': {cfg.access.asset.name}")
+        raise InvalidGlobalConfigurationError(
+            f"Invalid name in 'access.asset': {cfg.access.asset.name}"
+        )
 
     # Check masterdata
 
     # smda.country
     for country in cfg.masterdata.smda.country:
         if str(country.uuid) in INVALID_UUIDS:
-            raise ValueError(f"Invalid SMDA UUID in 'smda.country': {country.uuid}")
+            raise InvalidGlobalConfigurationError(
+                f"Invalid SMDA UUID in 'smda.country': {country.uuid}"
+            )
 
     # smda.discovery
     for discovery in cfg.masterdata.smda.discovery:
         if discovery.short_identifier.lower() in INVALID_NAMES:
-            raise ValueError(
+            raise InvalidGlobalConfigurationError(
                 f"Invalid SMDA short identifier in 'smda.discovery': "
                 f"{discovery.short_identifier}"
             )
         if str(discovery.uuid) in INVALID_UUIDS:
-            raise ValueError(f"Invalid SMDA UUID in 'smda.discovery': {discovery.uuid}")
+            raise InvalidGlobalConfigurationError(
+                f"Invalid SMDA UUID in 'smda.discovery': {discovery.uuid}"
+            )
 
     # smda.field
     for field in cfg.masterdata.smda.field:
         if field.identifier.lower() in INVALID_NAMES:
-            raise ValueError(
+            raise InvalidGlobalConfigurationError(
                 f"Invalid SMDA identifier in 'smda.field': {field.identifier}"
             )
         if str(field.uuid) in INVALID_UUIDS:
-            raise ValueError(f"Invalid SMDA UUID in 'smda.field': {field.uuid}")
+            raise InvalidGlobalConfigurationError(
+                f"Invalid SMDA UUID in 'smda.field': {field.uuid}"
+            )
 
     # smda.coordinate_system
     if (coord_uuid := str(cfg.masterdata.smda.coordinate_system.uuid)) in INVALID_UUIDS:
-        raise ValueError(f"Invalid SMDA UUID in 'smda.coordinate_system': {coord_uuid}")
+        raise InvalidGlobalConfigurationError(
+            f"Invalid SMDA UUID in 'smda.coordinate_system': {coord_uuid}"
+        )
 
     # smda.stratigraphic_column
     strat = cfg.masterdata.smda.stratigraphic_column
     if strat.identifier.lower() in INVALID_NAMES:
-        raise ValueError(
+        raise InvalidGlobalConfigurationError(
             f"Invalid SMDA identifier in 'smda.stratigraphic_column': "
             f"{strat.identifier}"
         )
     if str(strat.uuid) in INVALID_UUIDS:
-        raise ValueError(
+        raise InvalidGlobalConfigurationError(
             f"Invalid SMDA UUID in 'smda.stratigraphic_column': {strat.uuid}"
         )
 
@@ -102,7 +126,7 @@ def validate_global_configuration_strictly(cfg: GlobalConfiguration) -> None:  #
     if cfg.stratigraphy:
         for key in cfg.stratigraphy:
             if key.lower() in INVALID_STRAT_NAMES:
-                raise ValueError(
+                raise InvalidGlobalConfigurationError(
                     f"Invalid stratigraphy name in 'smda.stratigraphy': {key}"
                 )
 
@@ -121,15 +145,22 @@ def load_global_configuration_if_present(
         fmu_load: Whether or not to load in the custom 'fmu' format. Default False.
 
     Returns:
-        GlobalConfiguration instance or None.
+        GlobalConfiguration instance or None if file cannot be loaded.
+
+    Raises:
+        ValidationError: If the file is loaded but has invalid schema.
     """
     loader = "fmu" if fmu_load else "standard"
     try:
         global_variables_dict = yaml_load(path, loader=loader)
         global_config = GlobalConfiguration.model_validate(global_variables_dict)
         logger.debug(f"Global variables at {path} has valid settings data")
-    except Exception:
-        logger.debug(f"Global variables at {path} does not have valid settings data")
+    except ValidationError:
+        raise
+    except Exception as e:
+        logger.debug(
+            f"Failed to load global variables at {path}: {type(e).__name__}: {e}"
+        )
         return None
     return global_config
 
@@ -144,6 +175,9 @@ def _find_global_variables_file(paths: list[Path]) -> GlobalConfiguration | None
 
     Returns:
         A validated GlobalConfiguration or None.
+
+    Raises:
+        ValidationError: If a file is found but has invalid schema.
     """
     for path in paths:
         if not path.exists():
@@ -175,6 +209,9 @@ def _find_global_config_file(paths: list[Path]) -> GlobalConfiguration | None:
 
     Returns:
         A validated GlobalConfiguration or None.
+
+    Raises:
+        ValidationError: If a file is found but has invalid schema.
     """
     for path in paths:
         if not path.exists():
@@ -212,6 +249,11 @@ def find_global_config(
 
     Returns:
         A valid GlobalConfiguration instance, or None.
+
+    Raises:
+        ValidationError: If a configuration file is found but has invalid schema.
+        InvalidGlobalConfigurationError: If strict=True and configuration contains
+            disallowed content (e.g., Drogon data).
     """
     base_path = Path(base_path)
 

fmu_settings-0.5.1/src/fmu/settings/_resources/config_managers.py

@@ -0,0 +1,49 @@
+"""The generic configuration file in a .fmu directory."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Final, Self
+
+from fmu.settings._logging import null_logger
+from fmu.settings.models.project_config import ProjectConfig
+from fmu.settings.models.user_config import UserConfig
+
+from .pydantic_resource_manager import (
+    MutablePydanticResourceManager,
+)
+
+if TYPE_CHECKING:
+    # Avoid circular dependency for type hint in __init__ only
+    from fmu.settings._fmu_dir import (
+        ProjectFMUDirectory,
+        UserFMUDirectory,
+    )
+
+logger: Final = null_logger(__name__)
+
+
+class ProjectConfigManager(MutablePydanticResourceManager[ProjectConfig]):
+    """Manages the .fmu configuration file in a project."""
+
+    def __init__(self: Self, fmu_dir: ProjectFMUDirectory) -> None:
+        """Initializes the ProjectConfig resource manager."""
+        super().__init__(fmu_dir, ProjectConfig)
+
+    @property
+    def relative_path(self: Self) -> Path:
+        """Returns the relative path to the config file."""
+        return Path("config.json")
+
+
+class UserConfigManager(MutablePydanticResourceManager[UserConfig]):
+    """Manages the .fmu configuration file in a user's home directory."""
+
+    def __init__(self: Self, fmu_dir: UserFMUDirectory) -> None:
+        """Initializes the UserConfig resource manager."""
+        super().__init__(fmu_dir, UserConfig)
+
+    @property
+    def relative_path(self: Self) -> Path:
+        """Returns the relative path to the config file."""
+        return Path("config.json")

fmu_settings-0.4.0/src/fmu/settings/_resources/config_managers.py → fmu_settings-0.5.1/src/fmu/settings/_resources/pydantic_resource_manager.py

@@ -1,43 +1,124 @@
-"""The generic configuration file in a .fmu directory."""
+"""Contains the base class used for interacting with resources."""
 
 from __future__ import annotations
 
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Final, Self, TypeVar
+import json
+from typing import TYPE_CHECKING, Any, Generic, Self, TypeVar
 
-from pydantic import ValidationError
+from pydantic import BaseModel, ValidationError
 
-from fmu.settings._logging import null_logger
-from fmu.settings.models.project_config import ProjectConfig
-from fmu.settings.models.user_config import UserConfig
-from fmu.settings.types import ResettableBaseModel  # noqa: TC001
-
-from .pydantic_resource_manager import PydanticResourceManager
+from fmu.settings.types import ResettableBaseModel
 
 if TYPE_CHECKING:
     # Avoid circular dependency for type hint in __init__ only
-    from fmu.settings._fmu_dir import (
-        FMUDirectoryBase,
-        ProjectFMUDirectory,
-        UserFMUDirectory,
-    )
+    from pathlib import Path
 
-logger: Final = null_logger(__name__)
+    from fmu.settings._fmu_dir import FMUDirectoryBase
 
-T = TypeVar("T", bound=ResettableBaseModel)
+PydanticResource = TypeVar("PydanticResource", bound=BaseModel)
+MutablePydanticResource = TypeVar("MutablePydanticResource", bound=ResettableBaseModel)
 
 
-class ConfigManager(PydanticResourceManager[T]):
-    """Manages the .fmu configuration file."""
+class PydanticResourceManager(Generic[PydanticResource]):
+    """Base class for managing resources represented by Pydantic models."""
 
-    def __init__(self: Self, fmu_dir: FMUDirectoryBase, config: type[T]) -> None:
-        """Initializes the Config resource manager."""
-        super().__init__(fmu_dir, config)
+    def __init__(
+        self: Self, fmu_dir: FMUDirectoryBase, model_class: type[PydanticResource]
+    ) -> None:
+        """Initializes the resource manager.
+
+        Args:
+            fmu_dir: The FMUDirectory instance
+            model_class: The Pydantic model class this manager handles
+        """
+        self.fmu_dir = fmu_dir
+        self.model_class = model_class
+        self._cache: PydanticResource | None = None
 
     @property
     def relative_path(self: Self) -> Path:
-        """Returns the relative path to the config file."""
-        return Path("config.json")
+        """Returns the path to the resource file _inside_ the .fmu directory.
+
+        Must be implemented by subclasses.
+        """
+        raise NotImplementedError
+
+    @property
+    def path(self: Self) -> Path:
+        """Returns the full path to the resource file."""
+        return self.fmu_dir.get_file_path(self.relative_path)
+
+    @property
+    def exists(self: Self) -> bool:
+        """Returns whether or not the resource exists."""
+        return self.path.exists()
+
+    def load(
+        self: Self, force: bool = False, store_cache: bool = True
+    ) -> PydanticResource:
+        """Loads the resource from disk and validates it as a Pydantic model.
+
+        Args:
+            force: Force a re-read even if the file is already cached.
+            store_cache: Whether or not to cache the loaded model internally. This is
+                best used with 'force=True' because if a model is already stored in
+                _cache it will be returned without re-loading. Default True.
+
+        Returns:
+            Validated Pydantic model
+
+        Raises:
+            ValueError: If the resource file is missing or data does not match the
+            model schema
+        """
+        if self._cache is None or force:
+            if not self.exists:
+                raise FileNotFoundError(
+                    f"Resource file for '{self.__class__.__name__}' not found "
+                    f"at: '{self.path}'"
+                )
+
+            try:
+                content = self.fmu_dir.read_text_file(self.relative_path)
+                data = json.loads(content)
+                validated_model = self.model_class.model_validate(data)
+                if store_cache:
+                    self._cache = validated_model
+                else:
+                    return validated_model
+            except ValidationError as e:
+                raise ValueError(
+                    f"Invalid content in resource file for '{self.__class__.__name__}: "
+                    f"'{e}"
+                ) from e
+            except json.JSONDecodeError as e:
+                raise ValueError(
+                    f"Invalid JSON in resource file for '{self.__class__.__name__}': "
+                    f"'{e}'"
+                ) from e
+
+        return self._cache
+
+    def save(self: Self, model: PydanticResource) -> None:
+        """Save the Pydantic model to disk.
+
+        Args:
+            model: Validated Pydantic model instance
+        """
+        self.fmu_dir._lock.ensure_can_write()
+        json_data = model.model_dump_json(by_alias=True, indent=2)
+        self.fmu_dir.write_text_file(self.relative_path, json_data)
+        self._cache = model
+
+
+class MutablePydanticResourceManager(PydanticResourceManager[MutablePydanticResource]):
+    """Manages the .fmu configuration file."""
+
+    def __init__(
+        self: Self, fmu_dir: FMUDirectoryBase, config: type[MutablePydanticResource]
+    ) -> None:
+        """Initializes the Config resource manager."""
+        super().__init__(fmu_dir, config)
 
     def _get_dot_notation_key(
         self: Self, config_dict: dict[str, Any], key: str, default: Any = None
@@ -144,7 +225,7 @@ class ConfigManager(PydanticResourceManager[T]):
                 f"at: '{self.path}' when setting key {key}"
             ) from e
 
-    def update(self: Self, updates: dict[str, Any]) -> T:
+    def update(self: Self, updates: dict[str, Any]) -> MutablePydanticResource:
         """Updates multiple configuration values at once.
 
         Args:
@@ -183,7 +264,7 @@ class ConfigManager(PydanticResourceManager[T]):
 
         return updated_config
 
-    def reset(self: Self) -> T:
+    def reset(self: Self) -> MutablePydanticResource:
         """Resets the configuration to defaults.
 
         Returns:
@@ -192,19 +273,3 @@ class ConfigManager(PydanticResourceManager[T]):
         config = self.model_class.reset()
         self.save(config)
         return config
-
-
-class ProjectConfigManager(ConfigManager[ProjectConfig]):
-    """Manages the .fmu configuration file in a project."""
-
-    def __init__(self: Self, fmu_dir: ProjectFMUDirectory) -> None:
-        """Initializes the ProjectConfig resource manager."""
-        super().__init__(fmu_dir, ProjectConfig)
-
-
-class UserConfigManager(ConfigManager[UserConfig]):
-    """Manages the .fmu configuration file in a user's home directory."""
-
-    def __init__(self: Self, fmu_dir: UserFMUDirectory) -> None:
-        """Initializes the UserConfig resource manager."""
-        super().__init__(fmu_dir, UserConfig)

{fmu_settings-0.4.0 → fmu_settings-0.5.1}/src/fmu/settings/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.4.0'
-__version_tuple__ = version_tuple = (0, 4, 0)
+__version__ = version = '0.5.1'
+__version_tuple__ = version_tuple = (0, 5, 1)
 
-__commit_id__ = commit_id = 'g51366b17b'
+__commit_id__ = commit_id = 'g6786842d9'

{fmu_settings-0.4.0 → fmu_settings-0.5.1}/src/fmu_settings.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu-settings
-Version: 0.4.0
+Version: 0.5.1
 Summary: A library for managing FMU settings
 Author-email: Equinor <fg-fmu_atlas@equinor.com>
 License: GPL-3.0

{fmu_settings-0.4.0 → fmu_settings-0.5.1}/tests/test_global_config.py

@@ -13,8 +13,10 @@ from fmu.datamodels.fmu_results.global_configuration import (
     GlobalConfiguration,
     StratigraphyElement,
 )
+from pydantic import ValidationError
 
 from fmu.settings._global_config import (
+    InvalidGlobalConfigurationError,
     _find_global_config_file,
     _find_global_variables_file,
     find_global_config,
@@ -60,7 +62,9 @@ def test_validate_global_config_strict_model(
     if valid:
         validate_global_configuration_strictly(cfg)  # Does not raise
     else:
-        with pytest.raises(ValueError, match=f"Invalid name in 'model': {name}"):
+        with pytest.raises(
+            InvalidGlobalConfigurationError, match=f"Invalid name in 'model': {name}"
+        ):
             validate_global_configuration_strictly(cfg)
 
 
@@ -77,7 +81,10 @@ def test_validate_global_config_strict_access(
     if valid:
         validate_global_configuration_strictly(cfg)  # Does not raise
     else:
-        with pytest.raises(ValueError, match=f"Invalid name in 'access.asset': {name}"):
+        with pytest.raises(
+            InvalidGlobalConfigurationError,
+            match=f"Invalid name in 'access.asset': {name}",
+        ):
             validate_global_configuration_strictly(cfg)
 
 
@@ -98,7 +105,8 @@ def test_validate_global_config_strict_smda_country_uuid(
         validate_global_configuration_strictly(cfg)  # Does not raise
     else:
         with pytest.raises(
-            ValueError, match=f"Invalid SMDA UUID in 'smda.country': {uuid}"
+            InvalidGlobalConfigurationError,
+            match=f"Invalid SMDA UUID in 'smda.country': {uuid}",
         ):
             validate_global_configuration_strictly(cfg)
 
@@ -120,7 +128,7 @@ def test_validate_global_config_strict_smda_discovery_identifier(
         validate_global_configuration_strictly(cfg)  # Does not raise
     else:
         with pytest.raises(
-            ValueError,
+            InvalidGlobalConfigurationError,
             match=f"Invalid SMDA short identifier in 'smda.discovery': {identifier}",
         ):
             validate_global_configuration_strictly(cfg)
@@ -143,7 +151,7 @@ def test_validate_global_config_strict_smda_discovery_uuid(
         validate_global_configuration_strictly(cfg)  # Does not raise
     else:
         with pytest.raises(
-            ValueError,
+            InvalidGlobalConfigurationError,
             match=f"Invalid SMDA UUID in 'smda.discovery': {uuid}",
         ):
             validate_global_configuration_strictly(cfg)
@@ -166,7 +174,7 @@ def test_validate_global_config_strict_smda_field_identifier(
         validate_global_configuration_strictly(cfg)  # Does not raise
     else:
         with pytest.raises(
-            ValueError,
+            InvalidGlobalConfigurationError,
             match=f"Invalid SMDA identifier in 'smda.field': {identifier}",
         ):
             validate_global_configuration_strictly(cfg)
@@ -189,7 +197,7 @@ def test_validate_global_config_strict_smda_field_uuid(
         validate_global_configuration_strictly(cfg)  # Does not raise
     else:
         with pytest.raises(
-            ValueError,
+            InvalidGlobalConfigurationError,
             match=f"Invalid SMDA UUID in 'smda.field': {uuid}",
         ):
             validate_global_configuration_strictly(cfg)
@@ -209,7 +217,8 @@ def test_validate_global_config_strict_coordinate_system(
         validate_global_configuration_strictly(cfg)  # Does not raise
     else:
         with pytest.raises(
-            ValueError, match=f"Invalid SMDA UUID in 'smda.coordinate_system': {uuid}"
+            InvalidGlobalConfigurationError,
+            match=f"Invalid SMDA UUID in 'smda.coordinate_system': {uuid}",
         ):
             validate_global_configuration_strictly(cfg)
 
@@ -228,7 +237,7 @@ def test_validate_global_config_strict_stratigraphic_column_uuids(
         validate_global_configuration_strictly(cfg)  # Does not raise
     else:
         with pytest.raises(
-            ValueError,
+            InvalidGlobalConfigurationError,
             match=f"Invalid SMDA UUID in 'smda.stratigraphic_column': {uuid}",
         ):
             validate_global_configuration_strictly(cfg)
@@ -250,7 +259,7 @@ def test_validate_global_config_strict_stratigraphic_column_names(
         validate_global_configuration_strictly(cfg)  # Does not raise
     else:
         with pytest.raises(
-            ValueError,
+            InvalidGlobalConfigurationError,
             match=f"Invalid SMDA identifier in 'smda.stratigraphic_column': "
             f"{identifier}",
         ):
@@ -273,7 +282,7 @@ def test_validate_global_config_strict_stratigraphy_names(
         validate_global_configuration_strictly(cfg)  # Does not raise
     else:
         with pytest.raises(
-            ValueError,
+            InvalidGlobalConfigurationError,
             match=f"Invalid stratigraphy name in 'smda.stratigraphy': {identifier}",
         ):
             validate_global_configuration_strictly(cfg)
@@ -283,29 +292,51 @@ def test_validate_global_config_strict_stratigraphy_names(
 
 
 @pytest.mark.parametrize("fmu_load", [True, False])
-def test_load_global_configuration_returns_none_if_invalid_yaml(
+def test_load_global_configuration_raises_on_invalid_yaml_structure(
     fmu_load: bool, tmp_path: Path
 ) -> None:
-    """Tests maybe_load returns None if an Exception is raised."""
+    """Tests that ValidationError is raised for invalid YAML structure."""
     config_path = tmp_path / "global_config.yml"
     with open(config_path, "w") as f:
         f.write("foo=bar")
 
-    assert load_global_configuration_if_present(config_path, fmu_load=fmu_load) is None
+    with pytest.raises(ValidationError):
+        load_global_configuration_if_present(config_path, fmu_load=fmu_load)
 
 
 @pytest.mark.parametrize("fmu_load", [True, False])
-def test_load_global_configuration_returns_none_if_invalid_config(
+def test_load_global_configuration_raises_on_missing_required_fields(
     fmu_load: bool,
     tmp_path: Path,
     global_variables_with_masterdata: dict[str, Any],
 ) -> None:
-    """Tests maybe_load returns None if an Exception is raised."""
+    """Tests that ValidationError is raised for missing required fields."""
     config_path = tmp_path / "global_config.yml"
     del global_variables_with_masterdata["masterdata"]
     with open(config_path, "w") as f:
         yaml.safe_dump(global_variables_with_masterdata, f)
 
+    with pytest.raises(ValidationError):
+        load_global_configuration_if_present(config_path, fmu_load=fmu_load)
+
+
+@pytest.mark.parametrize("fmu_load", [True, False])
+def test_load_global_configuration_returns_none_on_file_not_found(
+    fmu_load: bool, tmp_path: Path
+) -> None:
+    """Tests that None is returned when file doesn't exist."""
+    config_path = tmp_path / "non_existent_file.yml"
+    assert load_global_configuration_if_present(config_path, fmu_load=fmu_load) is None
+
+
+@pytest.mark.parametrize("fmu_load", [True, False])
+def test_load_global_configuration_returns_none_on_yaml_parse_error(
+    fmu_load: bool, tmp_path: Path
+) -> None:
+    """Tests that None is returned on YAML parsing errors."""
+    config_path = tmp_path / "invalid.yml"
+    with open(config_path, "w") as f:
+        f.write("key: [unclosed list")
     assert load_global_configuration_if_present(config_path, fmu_load=fmu_load) is None
 
 
@@ -319,10 +350,23 @@ def test_find_global_config_file_not_there(tmp_path: Path) -> None:
     assert _find_global_config_file([tmp_path / "dne"]) is None
 
 
-def test_find_global_configs_file_malformed(tmp_path: Path) -> None:
-    """Tests finding the global config file if it is malformed."""
+def test_find_global_config_file_malformed_raises_validation_error(
+    tmp_path: Path,
+) -> None:
+    """Tests that malformed global config file raises ValidationError."""
     with open(tmp_path / "global_master_config.yml", "w") as f:
         f.write("foo: bar")
+    with pytest.raises(ValidationError):
+        _find_global_config_file([tmp_path])
+
+
+def test_find_global_config_file_skips_invalid_yaml_and_continues(
+    tmp_path: Path,
+) -> None:
+    """Tests that function skips files with YAML parse errors and continues."""
+    with open(tmp_path / "global_config.yml", "w") as f:
+        f.write("key: [unclosed list")
+
     assert _find_global_config_file([tmp_path]) is None
 
 
@@ -355,32 +399,55 @@ def test_find_global_variables_file_not_there(tmp_path: Path) -> None:
     assert _find_global_variables_file([tmp_path / "dne"]) is None
 
 
-def test_find_global_variables_file_malformed(tmp_path: Path) -> None:
-    """Tests finding the global variables file if it is malformed."""
+def test_find_global_variables_file_malformed_raises_validation_error(
+    tmp_path: Path,
+) -> None:
+    """Tests that malformed global variables file raises ValidationError."""
     with open(tmp_path / "global_variables.yml", "w") as f:
         f.write("foo: bar")
-    assert _find_global_variables_file([tmp_path]) is None
+    with pytest.raises(ValidationError):
+        _find_global_variables_file([tmp_path])
 
 
-def test_find_global_variables_file(fmuconfig_with_output: Path) -> None:
-    """Tests finding the global variables file in fmuconfig."""
+def test_find_global_variables_file_returns_none_when_not_found(
+    fmuconfig_with_output: Path,
+) -> None:
+    """Tests that None is returned when no global variables file exists."""
     tmp_path = fmuconfig_with_output
     some_dir = tmp_path / "some_dir"
     some_dir.mkdir()
-    some_file = some_dir / "some_file"
-    some_file.touch()
     does_not_exist = tmp_path / "bad"
-    assert _find_global_variables_file([does_not_exist, some_dir, some_file]) is None
+    assert _find_global_variables_file([does_not_exist, some_dir]) is None
+
+
+def test_find_global_variables_file_skips_invalid_yaml_and_continues(
+    tmp_path: Path,
+) -> None:
+    """Tests that function skips files with YAML parse errors and continues."""
+    invalid_yaml_file = tmp_path / "global_variables.yml"
+    with open(invalid_yaml_file, "w") as f:
+        f.write("key: [unclosed list")
 
+    assert _find_global_variables_file([tmp_path]) is None
+
+
+def test_find_global_variables_file_raises_on_empty_file(
+    fmuconfig_with_output: Path,
+) -> None:
+    """Tests that ValidationError is raised for empty/invalid file."""
+    tmp_path = fmuconfig_with_output
+    some_file = tmp_path / "some_file"
+    some_file.touch()
+    with pytest.raises(ValidationError):
+        _find_global_variables_file([some_file])
+
+
+def test_find_global_variables_file_returns_valid_config(
+    fmuconfig_with_output: Path,
+) -> None:
+    """Tests finding a valid global variables file in fmuconfig."""
     assert isinstance(
-        _find_global_variables_file(
-            [
-                does_not_exist,
-                some_dir,
-                some_file,
-                fmuconfig_with_output / "fmuconfig/output",
-            ]
-        ),
+        _find_global_variables_file([fmuconfig_with_output / "fmuconfig/output"]),
         GlobalConfiguration,
     )
 
@@ -420,7 +487,9 @@ def test_find_global_config_from_input_strict(
 ) -> None:
     """Tests finding a global config with 'Drogon' in it raises."""
     tmp_path = fmuconfig_with_input
-    with pytest.raises(ValueError, match="Invalid name in 'model': Drogon"):
+    with pytest.raises(
+        InvalidGlobalConfigurationError, match="Invalid name in 'model': Drogon"
+    ):
         find_global_config(tmp_path)
 
 
@@ -439,7 +508,9 @@ def test_find_global_config_extra_output_paths(
     )
     assert isinstance(cfg, GlobalConfiguration)
 
-    with pytest.raises(ValueError, match="Invalid name in 'model': Drogon"):
+    with pytest.raises(
+        InvalidGlobalConfigurationError, match="Invalid name in 'model': Drogon"
+    ):
         find_global_config(
             base_path,
             extra_output_paths=[tmp_path / "fmuconfig/output/global_variables.yml"],
@@ -462,7 +533,9 @@ def test_find_global_config_extra_input_paths(
     )
     assert isinstance(cfg, GlobalConfiguration)
 
-    with pytest.raises(ValueError, match="Invalid name in 'model': Drogon"):
+    with pytest.raises(
+        InvalidGlobalConfigurationError, match="Invalid name in 'model': Drogon"
+    ):
         find_global_config(
             base_path,
             extra_input_dirs=[tmp_path / "fmuconfig/input"],

fmu_settings-0.4.0/src/fmu/settings/_resources/pydantic_resource_manager.py

@@ -1,104 +0,0 @@
-"""Contains the base class used for interacting with resources."""
-
-from __future__ import annotations
-
-import json
-from typing import TYPE_CHECKING, Generic, Self, TypeVar
-
-from pydantic import BaseModel, ValidationError
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-    # Avoid circular dependency for type hint in __init__ only
-    from fmu.settings._fmu_dir import FMUDirectoryBase
-
-T = TypeVar("T", bound=BaseModel)
-
-
-class PydanticResourceManager(Generic[T]):
-    """Base class for managing resources represented by Pydantic models."""
-
-    def __init__(self: Self, fmu_dir: FMUDirectoryBase, model_class: type[T]) -> None:
-        """Initializes the resource manager.
-
-        Args:
-            fmu_dir: The FMUDirectory instance
-            model_class: The Pydantic model class this manager handles
-        """
-        self.fmu_dir = fmu_dir
-        self.model_class = model_class
-        self._cache: T | None = None
-
-    @property
-    def relative_path(self: Self) -> Path:
-        """Returns the path to the resource file _inside_ the .fmu directory.
-
-        Must be implemented by subclasses.
-        """
-        raise NotImplementedError
-
-    @property
-    def path(self: Self) -> Path:
-        """Returns the full path to the resource file."""
-        return self.fmu_dir.get_file_path(self.relative_path)
-
-    @property
-    def exists(self: Self) -> bool:
-        """Returns whether or not the resource exists."""
-        return self.path.exists()
-
-    def load(self: Self, force: bool = False, store_cache: bool = True) -> T:
-        """Loads the resource from disk and validates it as a Pydantic model.
-
-        Args:
-            force: Force a re-read even if the file is already cached.
-            store_cache: Whether or not to cache the loaded model internally. This is
-                best used with 'force=True' because if a model is already stored in
-                _cache it will be returned without re-loading. Default True.
-
-        Returns:
-            Validated Pydantic model
-
-        Raises:
-            ValueError: If the resource file is missing or data does not match the
-            model schema
-        """
-        if self._cache is None or force:
-            if not self.exists:
-                raise FileNotFoundError(
-                    f"Resource file for '{self.__class__.__name__}' not found "
-                    f"at: '{self.path}'"
-                )
-
-            try:
-                content = self.fmu_dir.read_text_file(self.relative_path)
-                data = json.loads(content)
-                validated_model = self.model_class.model_validate(data)
-                if store_cache:
-                    self._cache = validated_model
-                else:
-                    return validated_model
-            except ValidationError as e:
-                raise ValueError(
-                    f"Invalid content in resource file for '{self.__class__.__name__}: "
-                    f"'{e}"
-                ) from e
-            except json.JSONDecodeError as e:
-                raise ValueError(
-                    f"Invalid JSON in resource file for '{self.__class__.__name__}': "
-                    f"'{e}'"
-                ) from e
-
-        return self._cache
-
-    def save(self: Self, model: T) -> None:
-        """Save the Pydantic model to disk.
-
-        Args:
-            model: Validated Pydantic model instance
-        """
-        self.fmu_dir._lock.ensure_can_write()
-        json_data = model.model_dump_json(by_alias=True, indent=2)
-        self.fmu_dir.write_text_file(self.relative_path, json_data)
-        self._cache = model