fmu-settings 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

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/_resources/config_managers.py

@@ -3,208 +3,47 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Final, Self, TypeVar
-
-from pydantic import ValidationError
+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 fmu.settings.types import ResettableBaseModel  # noqa: TC001
 
-from .pydantic_resource_manager import PydanticResourceManager
+from .pydantic_resource_manager import (
+    MutablePydanticResourceManager,
+)
 
 if TYPE_CHECKING:
     # Avoid circular dependency for type hint in __init__ only
     from fmu.settings._fmu_dir import (
-        FMUDirectoryBase,
         ProjectFMUDirectory,
         UserFMUDirectory,
     )
 
 logger: Final = null_logger(__name__)
 
-T = TypeVar("T", bound=ResettableBaseModel)
-
 
-class ConfigManager(PydanticResourceManager[T]):
-    """Manages the .fmu configuration file."""
+class ProjectConfigManager(MutablePydanticResourceManager[ProjectConfig]):
+    """Manages the .fmu configuration file in a project."""
 
-    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: 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")
 
-    def _get_dot_notation_key(
-        self: Self, config_dict: dict[str, Any], key: str, default: Any = None
-    ) -> Any:
-        """Sets the value to a dot-notation key.
-
-        Args:
-            config_dict: The configuration dictionary we are modifying (by reference)
-            key: The key to set
-            default: Value to return if key is not found. Default None
-
-        Returns:
-            The value or default
-        """
-        parts = key.split(".")
-        value = config_dict
-        for part in parts:
-            if isinstance(value, dict) and part in value:
-                value = value[part]
-            else:
-                return default
-
-        return value
-
-    def get(self: Self, key: str, default: Any = None) -> Any:
-        """Gets a configuration value by key.
-
-        Supports dot notation for nested values (e.g., "foo.bar")
-
-        Args:
-            key: The configuration key
-            default: Value to return if key is not found. Default None
-
-        Returns:
-            The configuration value or default
-        """
-        try:
-            config = self.load()
-
-            if "." in key:
-                return self._get_dot_notation_key(config.model_dump(), key, default)
-
-            if hasattr(config, key):
-                return getattr(config, key)
-
-            config_dict = config.model_dump()
-            return config_dict.get(key, default)
-        except FileNotFoundError as e:
-            raise FileNotFoundError(
-                f"Resource file for '{self.__class__.__name__}' not found "
-                f"at: '{self.path}' when getting key {key}"
-            ) from e
-
-    def _set_dot_notation_key(
-        self: Self, config_dict: dict[str, Any], key: str, value: Any
-    ) -> None:
-        """Sets the value to a dot-notation key.
-
-        Args:
-            config_dict: The configuration dictionary we are modifying (by reference)
-            key: The key to set
-            value: The value to set
-        """
-        parts = key.split(".")
-        target = config_dict
-
-        for part in parts[:-1]:
-            if part not in target or not isinstance(target[part], dict):
-                target[part] = {}
-            target = target[part]
-
-        target[parts[-1]] = value
-
-    def set(self: Self, key: str, value: Any) -> None:
-        """Sets a configuration value by key.
-
-        Args:
-            key: The configuration key
-            value: The value to set
-
-        Raises:
-            FileNotFoundError: If config file doesn't exist
-            ValueError: If the updated config is invalid
-        """
-        try:
-            config = self.load()
-            config_dict = config.model_dump()
-
-            if "." in key:
-                self._set_dot_notation_key(config_dict, key, value)
-            else:
-                config_dict[key] = value
 
-            updated_config = config.model_validate(config_dict)
-            self.save(updated_config)
-        except ValidationError as e:
-            raise ValueError(
-                f"Invalid value set for '{self.__class__.__name__}' with "
-                f"key '{key}', value '{value}': '{e}"
-            ) from e
-        except FileNotFoundError as e:
-            raise FileNotFoundError(
-                f"Resource file for '{self.__class__.__name__}' not found "
-                f"at: '{self.path}' when setting key {key}"
-            ) from e
-
-    def update(self: Self, updates: dict[str, Any]) -> T:
-        """Updates multiple configuration values at once.
-
-        Args:
-            updates: Dictionary of key-value pairs to update
-
-        Returns:
-            The updated Config object
-
-        Raises:
-            FileNotFoundError: If config file doesn't exist
-            ValueError: If the updates config is invalid
-        """
-        try:
-            config = self.load()
-            config_dict = config.model_dump()
-
-            flat_updates = {k: v for k, v in updates.items() if "." not in k}
-            config_dict.update(flat_updates)
-
-            for key, value in updates.items():
-                if "." in key:
-                    self._set_dot_notation_key(config_dict, key, value)
-
-                updated_config = config.model_validate(config_dict)
-            self.save(updated_config)
-        except ValidationError as e:
-            raise ValueError(
-                f"Invalid value set for '{self.__class__.__name__}' with "
-                f"updates '{updates}': '{e}"
-            ) from e
-        except FileNotFoundError as e:
-            raise FileNotFoundError(
-                f"Resource file for '{self.__class__.__name__}' not found "
-                f"at: '{self.path}' when setting updates {updates}"
-            ) from e
-
-        return updated_config
-
-    def reset(self: Self) -> T:
-        """Resets the configuration to defaults.
-
-        Returns:
-            The new default config object
-        """
-        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]):
+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/_resources/pydantic_resource_manager.py

@@ -3,23 +3,28 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, Generic, Self, TypeVar
+from typing import TYPE_CHECKING, Any, Generic, Self, TypeVar
 
 from pydantic import BaseModel, ValidationError
 
+from fmu.settings.types import ResettableBaseModel
+
 if TYPE_CHECKING:
+    # Avoid circular dependency for type hint in __init__ only
     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)
+PydanticResource = TypeVar("PydanticResource", bound=BaseModel)
+MutablePydanticResource = TypeVar("MutablePydanticResource", bound=ResettableBaseModel)
 
 
-class PydanticResourceManager(Generic[T]):
+class PydanticResourceManager(Generic[PydanticResource]):
     """Base class for managing resources represented by Pydantic models."""
 
-    def __init__(self: Self, fmu_dir: FMUDirectoryBase, model_class: type[T]) -> None:
+    def __init__(
+        self: Self, fmu_dir: FMUDirectoryBase, model_class: type[PydanticResource]
+    ) -> None:
         """Initializes the resource manager.
 
         Args:
@@ -28,7 +33,7 @@ class PydanticResourceManager(Generic[T]):
         """
         self.fmu_dir = fmu_dir
         self.model_class = model_class
-        self._cache: T | None = None
+        self._cache: PydanticResource | None = None
 
     @property
     def relative_path(self: Self) -> Path:
@@ -48,7 +53,9 @@ class PydanticResourceManager(Generic[T]):
         """Returns whether or not the resource exists."""
         return self.path.exists()
 
-    def load(self: Self, force: bool = False, store_cache: bool = True) -> T:
+    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:
@@ -92,7 +99,7 @@ class PydanticResourceManager(Generic[T]):
 
         return self._cache
 
-    def save(self: Self, model: T) -> None:
+    def save(self: Self, model: PydanticResource) -> None:
         """Save the Pydantic model to disk.
 
         Args:
@@ -102,3 +109,167 @@ class PydanticResourceManager(Generic[T]):
         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
+    ) -> Any:
+        """Sets the value to a dot-notation key.
+
+        Args:
+            config_dict: The configuration dictionary we are modifying (by reference)
+            key: The key to set
+            default: Value to return if key is not found. Default None
+
+        Returns:
+            The value or default
+        """
+        parts = key.split(".")
+        value = config_dict
+        for part in parts:
+            if isinstance(value, dict) and part in value:
+                value = value[part]
+            else:
+                return default
+
+        return value
+
+    def get(self: Self, key: str, default: Any = None) -> Any:
+        """Gets a configuration value by key.
+
+        Supports dot notation for nested values (e.g., "foo.bar")
+
+        Args:
+            key: The configuration key
+            default: Value to return if key is not found. Default None
+
+        Returns:
+            The configuration value or default
+        """
+        try:
+            config = self.load()
+
+            if "." in key:
+                return self._get_dot_notation_key(config.model_dump(), key, default)
+
+            if hasattr(config, key):
+                return getattr(config, key)
+
+            config_dict = config.model_dump()
+            return config_dict.get(key, default)
+        except FileNotFoundError as e:
+            raise FileNotFoundError(
+                f"Resource file for '{self.__class__.__name__}' not found "
+                f"at: '{self.path}' when getting key {key}"
+            ) from e
+
+    def _set_dot_notation_key(
+        self: Self, config_dict: dict[str, Any], key: str, value: Any
+    ) -> None:
+        """Sets the value to a dot-notation key.
+
+        Args:
+            config_dict: The configuration dictionary we are modifying (by reference)
+            key: The key to set
+            value: The value to set
+        """
+        parts = key.split(".")
+        target = config_dict
+
+        for part in parts[:-1]:
+            if part not in target or not isinstance(target[part], dict):
+                target[part] = {}
+            target = target[part]
+
+        target[parts[-1]] = value
+
+    def set(self: Self, key: str, value: Any) -> None:
+        """Sets a configuration value by key.
+
+        Args:
+            key: The configuration key
+            value: The value to set
+
+        Raises:
+            FileNotFoundError: If config file doesn't exist
+            ValueError: If the updated config is invalid
+        """
+        try:
+            config = self.load()
+            config_dict = config.model_dump()
+
+            if "." in key:
+                self._set_dot_notation_key(config_dict, key, value)
+            else:
+                config_dict[key] = value
+
+            updated_config = config.model_validate(config_dict)
+            self.save(updated_config)
+        except ValidationError as e:
+            raise ValueError(
+                f"Invalid value set for '{self.__class__.__name__}' with "
+                f"key '{key}', value '{value}': '{e}"
+            ) from e
+        except FileNotFoundError as e:
+            raise FileNotFoundError(
+                f"Resource file for '{self.__class__.__name__}' not found "
+                f"at: '{self.path}' when setting key {key}"
+            ) from e
+
+    def update(self: Self, updates: dict[str, Any]) -> MutablePydanticResource:
+        """Updates multiple configuration values at once.
+
+        Args:
+            updates: Dictionary of key-value pairs to update
+
+        Returns:
+            The updated Config object
+
+        Raises:
+            FileNotFoundError: If config file doesn't exist
+            ValueError: If the updates config is invalid
+        """
+        try:
+            config = self.load()
+            config_dict = config.model_dump()
+
+            flat_updates = {k: v for k, v in updates.items() if "." not in k}
+            config_dict.update(flat_updates)
+
+            for key, value in updates.items():
+                if "." in key:
+                    self._set_dot_notation_key(config_dict, key, value)
+
+                updated_config = config.model_validate(config_dict)
+            self.save(updated_config)
+        except ValidationError as e:
+            raise ValueError(
+                f"Invalid value set for '{self.__class__.__name__}' with "
+                f"updates '{updates}': '{e}"
+            ) from e
+        except FileNotFoundError as e:
+            raise FileNotFoundError(
+                f"Resource file for '{self.__class__.__name__}' not found "
+                f"at: '{self.path}' when setting updates {updates}"
+            ) from e
+
+        return updated_config
+
+    def reset(self: Self) -> MutablePydanticResource:
+        """Resets the configuration to defaults.
+
+        Returns:
+            The new default config object
+        """
+        config = self.model_class.reset()
+        self.save(config)
+        return config

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 = None

{fmu_settings-0.4.0.dist-info → fmu_settings-0.5.1.dist-info}/METADATA

@@ -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.dist-info → fmu_settings-0.5.1.dist-info}/RECORD

@@ -1,24 +1,24 @@
 fmu/__init__.py,sha256=htx6HlMme77I6pZ8U256-2B2cMJuELsu3JN3YM2Efh4,144
 fmu/settings/__init__.py,sha256=CkEE7al_uBCQO1lxBKN5LzyCwzzH5Aq6kkEIR7f-zTw,336
 fmu/settings/_fmu_dir.py,sha256=XeZjec78q0IUOpBq-VMkKoWtzXwBeQi2qWRIh_SIFwU,10859
-fmu/settings/_global_config.py,sha256=YEl0_51_ZG28Ix-Km0q7lDL0myOsD3a0Sqky8T5Swcg,8021
+fmu/settings/_global_config.py,sha256=C0_o99OhOc49ynz4h6ygbbHHH8OOI5lcVFr-9FCwD0c,9331
 fmu/settings/_init.py,sha256=ucueS0BlEsM3MkX7IaRISloH4vF7-_ZKSphrORbHgJ4,4381
 fmu/settings/_logging.py,sha256=nEdmZlNCBsB1GfDmFMKCjZmeuRp3CRlbz1EYUemc95Y,1104
-fmu/settings/_version.py,sha256=2_0GUP7yBCXRus-qiJKxQD62z172WSs1sQ6DVpPsbmM,704
+fmu/settings/_version.py,sha256=cYMOhuaBHd0MIZmumuccsEQ-AxM8LIJy9dsBAWgOpqE,704
 fmu/settings/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fmu/settings/types.py,sha256=aeXEsznBTT1YRRY_LSRqK1j2gmMmyLYYTGYl3a9fweU,513
 fmu/settings/_resources/__init__.py,sha256=LHYR_F7lNGdv8N6R3cEwds5CJQpkOthXFqsEs24vgF8,118
-fmu/settings/_resources/config_managers.py,sha256=IjOtS2lSU55GE_TWqHjbBPAzE8xQyVBvpHcfm0hTSnI,6822
+fmu/settings/_resources/config_managers.py,sha256=QcCLlSw8KdJKrkhGax5teFJzjgQG3ym7Ljs1DykjFbc,1570
 fmu/settings/_resources/lock_manager.py,sha256=zdv1BZJlgB1BO9NepAdjY-YZ1-57HEJcTApE4UVS-8M,9995
-fmu/settings/_resources/pydantic_resource_manager.py,sha256=TbwpX0RPV0XAJ_fuVYCJTi00DBykvmvJH82B7bhREWo,3601
+fmu/settings/_resources/pydantic_resource_manager.py,sha256=AVvBUPnYOzmFYo9k5cA9QUme6ZOu0Q3IoLx_le7Mq20,9264
 fmu/settings/models/__init__.py,sha256=lRlXgl55ba2upmDzdvzx8N30JMq2Osnm8aa_xxTZn8A,112
 fmu/settings/models/_enums.py,sha256=SQUZ-2mQcTx4F0oefPFfuQzMKsKTSFSB-wq_CH7TBRE,734
 fmu/settings/models/_mappings.py,sha256=Z4Ex7MtmajBr6FjaNzmwDRwtJlaZZ8YKh9NDmZHRKPI,2832
 fmu/settings/models/lock_info.py,sha256=-oHDF9v9bDLCoFvEg4S6XXYLeo19zRAZ8HynCv75VWg,711
 fmu/settings/models/project_config.py,sha256=pxb54JmpXNMVAFUu_yJ89dNrYEk6hrPuFfFUpf84Jh0,1099
 fmu/settings/models/user_config.py,sha256=dWFTcZY6UnEgNTuGqB-izraJ657PecsW0e0Nt9GBDhI,2666
-fmu_settings-0.4.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-fmu_settings-0.4.0.dist-info/METADATA,sha256=btR8JyHVO9zr_ghzoKoV3I016ePj_Y2ijakSnFnbLMA,2116
-fmu_settings-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fmu_settings-0.4.0.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
-fmu_settings-0.4.0.dist-info/RECORD,,
+fmu_settings-0.5.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+fmu_settings-0.5.1.dist-info/METADATA,sha256=kVJutk6xJAJ2bHHn-VgKuhoIMtu761lgvC6G5LAr4kM,2116
+fmu_settings-0.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fmu_settings-0.5.1.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
+fmu_settings-0.5.1.dist-info/RECORD,,