fmu-settings 0.3.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

fmu/settings/_fmu_dir.py

@@ -82,7 +82,9 @@ class FMUDirectoryBase:
             FileNotFoundError: If config file doesn't exist
             ValueError: If the updated config is invalid
         """
+        logger.info(f"Setting {key} in {self.path}")
         self.config.set(key, value)
+        logger.debug(f"Set {key} to {value}")
 
     def update_config(
         self: Self, updates: dict[str, Any]
@@ -147,6 +149,7 @@ class FMUDirectoryBase:
             relative_path: Path relative to the .fmu directory
             data: Bytes to write
         """
+        self._lock.ensure_can_write()
         file_path = self.get_file_path(relative_path)
         file_path.parent.mkdir(parents=True, exist_ok=True)
 
@@ -163,6 +166,7 @@ class FMUDirectoryBase:
             content: Text content to write
             encoding: Text encoding to use. Default utf-8
         """
+        self._lock.ensure_can_write()
         file_path = self.get_file_path(relative_path)
         file_path.parent.mkdir(parents=True, exist_ok=True)
 

fmu/settings/_global_config.py

@@ -0,0 +1,270 @@
+"""Functions related to finding and validating an existing global configuration."""
+
+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
+
+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",
+    "drogon_2020",
+    "drogon_has_no_stratcolumn",
+)
+INVALID_UUIDS: Final[tuple[str, ...]] = (
+    "ad214d85-dac7-19da-e053-c918a4889309",
+    "ad214d85-8a1d-19da-e053-c918a4889310",
+    "00000000-0000-0000-0000-000000000000",
+)
+INVALID_STRAT_NAMES: Final[tuple[str, ...]] = (
+    "basevolantis",
+    "basetherys",
+    "basevalysar",
+    "basevolon",
+    "therys",
+    "toptherys",
+    "topvolantis",
+    "topvolon",
+    "topvalysar",
+    "valysar",
+    "volantis",
+    "volon",
+)
+
+
+def validate_global_configuration_strictly(cfg: GlobalConfiguration) -> None:  # noqa: PLR0912
+    """Does stricter checks against a valid GlobalConfiguration file.
+
+    This is to prevent importing existing but incorrect data that should not make it
+    into a project .fmu configuration. An example of this is Drogon masterdata.
+
+    Args:
+        cfg: A GlobalConfiguration instance to be validated
+
+    Raises:
+        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 InvalidGlobalConfigurationError(
+            f"Invalid name in 'model': {cfg.model.name}"
+        )
+    if cfg.access.asset.name.lower() in INVALID_NAMES:
+        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 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 InvalidGlobalConfigurationError(
+                f"Invalid SMDA short identifier in 'smda.discovery': "
+                f"{discovery.short_identifier}"
+            )
+        if str(discovery.uuid) in INVALID_UUIDS:
+            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 InvalidGlobalConfigurationError(
+                f"Invalid SMDA identifier in 'smda.field': {field.identifier}"
+            )
+        if str(field.uuid) in INVALID_UUIDS:
+            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 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 InvalidGlobalConfigurationError(
+            f"Invalid SMDA identifier in 'smda.stratigraphic_column': "
+            f"{strat.identifier}"
+        )
+    if str(strat.uuid) in INVALID_UUIDS:
+        raise InvalidGlobalConfigurationError(
+            f"Invalid SMDA UUID in 'smda.stratigraphic_column': {strat.uuid}"
+        )
+
+    # Check stratigraphy
+
+    if cfg.stratigraphy:
+        for key in cfg.stratigraphy:
+            if key.lower() in INVALID_STRAT_NAMES:
+                raise InvalidGlobalConfigurationError(
+                    f"Invalid stratigraphy name in 'smda.stratigraphy': {key}"
+                )
+
+
+def load_global_configuration_if_present(
+    path: Path, fmu_load: bool = False
+) -> GlobalConfiguration | None:
+    """Loads a global config/global variables at a path.
+
+    This loads via fmu-config, which is capable of loading a global _config_, which is
+    different from the global _variables_ in that it may still be in separate files
+    linked by the custom '!include' directive.
+
+    Args:
+        path: The path to the yaml file
+        fmu_load: Whether or not to load in the custom 'fmu' format. Default False.
+
+    Returns:
+        GlobalConfiguration instance or None.
+    """
+    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 ValidationError as e:
+        logger.debug(f"Global variables at {path} failed validation: {e}")
+        return None
+    except Exception as e:
+        logger.debug(
+            f"Failed to load global variables at {path}: {type(e).__name__}: {e}"
+        )
+        return None
+    return global_config
+
+
+def _find_global_variables_file(paths: list[Path]) -> GlobalConfiguration | None:
+    """Finds a valid global variables file, or not.
+
+    This is the _output_ file after fmuconfig is run.
+
+    Args:
+        paths: A list of Paths to check.
+
+    Returns:
+        A validated GlobalConfiguration or None.
+    """
+    for path in paths:
+        if not path.exists():
+            continue
+
+        global_variables_path = path
+        # If the path is a dir, and doesn't contain the right file, move on.
+        if path.is_dir():
+            global_variables_path = path / "global_variables.yml"
+            if not global_variables_path.exists():
+                continue
+
+        logger.info(f"Found global variables at {path}")
+        global_config = load_global_configuration_if_present(global_variables_path)
+        if not global_config:
+            continue
+        return global_config
+
+    return None
+
+
+def _find_global_config_file(paths: list[Path]) -> GlobalConfiguration | None:
+    """Finds a valid global configuration file, or not.
+
+    This is the _input_ file, before fmuconfig is run.
+
+    Args:
+        paths: A list of Paths to check.
+
+    Returns:
+        A validated GlobalConfiguration or None.
+    """
+    for path in paths:
+        if not path.exists():
+            continue
+
+        logger.info(f"Found global config at {path}")
+        # May be global_config*.yml or global_master*.yml
+        for global_config_path in path.glob("**/global*.yml"):
+            global_config = load_global_configuration_if_present(
+                global_config_path, fmu_load=True
+            )
+            if not global_config:
+                continue
+            return global_config
+
+    return None
+
+
+def find_global_config(
+    base_path: str | Path,
+    extra_output_paths: list[Path] | None = None,
+    extra_input_dirs: list[Path] | None = None,
+    strict: bool = True,
+) -> GlobalConfiguration | None:
+    """Try to locate a global configuration with valid masterdata in known location.
+
+    Extra paths may be provided
+
+    Args:
+        base_path: The path to the project root
+        extra_output_paths: A list of extra paths to a global _variables_.
+        extra_input_dirs: A list of extra dirs to a global _config_ might be.
+        strict: If True, valid data but invalid _content_ is disallowed, i.e.  Drogon
+            data. Default True.
+
+    Returns:
+        A valid GlobalConfiguration instance, or None.
+    """
+    base_path = Path(base_path)
+
+    # Loads with 'fmu_load=False'
+    known_output_paths = [base_path / "fmuconfig/output/global_variables.yml"]
+    if extra_output_paths:
+        known_output_paths += extra_output_paths
+
+    global_config = _find_global_variables_file(known_output_paths)
+    if global_config:
+        if strict:
+            validate_global_configuration_strictly(global_config)
+        return global_config
+
+    # Loads with 'fmu_load=True'
+    known_input_paths = [base_path / "fmuconfig/input"]
+    if extra_input_dirs:
+        known_input_paths += extra_input_dirs
+
+    global_config = _find_global_config_file(known_input_paths)
+    if global_config:
+        if strict:
+            validate_global_configuration_strictly(global_config)
+        return global_config
+
+    logger.info("No global variables or config with valid settings data found.")
+    return None

fmu/settings/_init.py

@@ -4,6 +4,8 @@ from pathlib import Path
 from textwrap import dedent
 from typing import Any, Final
 
+from fmu.datamodels.fmu_results.global_configuration import GlobalConfiguration
+
 from ._fmu_dir import ProjectFMUDirectory, UserFMUDirectory
 from ._logging import null_logger
 from .models.project_config import ProjectConfig
@@ -66,7 +68,9 @@ def _create_fmu_directory(base_path: Path) -> None:
 
 
 def init_fmu_directory(
-    base_path: str | Path, config_data: ProjectConfig | dict[str, Any] | None = None
+    base_path: str | Path,
+    config_data: ProjectConfig | dict[str, Any] | None = None,
+    global_config: GlobalConfiguration | None = None,
 ) -> ProjectFMUDirectory:
     """Creates and initializes a .fmu directory.
 
@@ -74,9 +78,11 @@ def init_fmu_directory(
     function.
 
     Args:
-        base_path: Directory where .fmu should be created
+        base_path: Directory where .fmu should be created.
         config_data: Optional ProjectConfig instance or dictionary with configuration
-          data
+          data.
+        global_config: Optional GlobaConfiguration instance with existing global config
+          data.
 
     Returns:
         Instance of FMUDirectory
@@ -98,12 +104,14 @@ def init_fmu_directory(
     fmu_dir.config.reset()
     if config_data:
         if isinstance(config_data, ProjectConfig):
-            config_dict = config_data.model_dump()
-            fmu_dir.update_config(config_dict)
-        elif isinstance(config_data, dict):
-            fmu_dir.update_config(config_data)
+            config_data = config_data.model_dump()
+        fmu_dir.update_config(config_data)
 
-    logger.debug(f"Successfully initialized .fmu directory at '{fmu_dir}'")
+    if global_config:
+        for key, value in global_config.model_dump().items():
+            fmu_dir.set_config_value(key, value)
+
+    logger.info(f"Successfully initialized .fmu directory at '{fmu_dir}'")
     return fmu_dir
 
 

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/lock_manager.py

@@ -168,6 +168,25 @@ class LockManager(PydanticResourceManager[LockInfo]):
             return False
         return self._is_mine(self._cache) and not self._is_stale()
 
+    def ensure_can_write(self: Self) -> None:
+        """Raise PermissionError if another process currently holds the lock."""
+        try:
+            lock_info = self.load(force=True, store_cache=False)
+        except Exception:
+            lock_info = None
+
+        if (
+            self.exists
+            and lock_info is not None
+            and not self.is_acquired()
+            and not self._is_stale(lock_info=lock_info)
+        ):
+            raise PermissionError(
+                "Cannot write to .fmu directory because it is locked by "
+                f"{lock_info.user}@{lock_info.hostname} (PID: {lock_info.pid}). "
+                f"Lock expires at {time.ctime(lock_info.expires_at)}."
+            )
+
     def refresh(self: Self) -> None:
         """Refresh/extend the lock expiration time.
 
@@ -239,9 +258,11 @@ class LockManager(PydanticResourceManager[LockInfo]):
         except Exception:
             return None
 
-    def _is_stale(self: Self) -> bool:
+    def _is_stale(self: Self, lock_info: LockInfo | None = None) -> bool:
         """Check if existing lock is stale (expired or process dead)."""
-        lock_info = self._safe_load()
+        if lock_info is None:
+            lock_info = self._safe_load()
+
         if not lock_info:
             return True
 

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,12 +99,177 @@ 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:
             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
+    ) -> 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.3.2'
-__version_tuple__ = version_tuple = (0, 3, 2)
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)
 
 __commit_id__ = commit_id = None

{fmu_settings-0.3.2.dist-info → fmu_settings-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu-settings
-Version: 0.3.2
+Version: 0.5.0
 Summary: A library for managing FMU settings
 Author-email: Equinor <fg-fmu_atlas@equinor.com>
 License: GPL-3.0
@@ -17,7 +17,9 @@ Classifier: Natural Language :: English
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: PyYAML
 Requires-Dist: annotated_types
+Requires-Dist: fmu-config
 Requires-Dist: fmu-datamodels
 Requires-Dist: pydantic
 Provides-Extra: dev
@@ -27,6 +29,7 @@ Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-mock; extra == "dev"
 Requires-Dist: pytest-xdist; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
+Requires-Dist: types-PyYAML; extra == "dev"
 Dynamic: license-file
 
 # fmu-settings

{fmu_settings-0.3.2.dist-info → fmu_settings-0.5.0.dist-info}/RECORD

@@ -1,23 +1,24 @@
 fmu/__init__.py,sha256=htx6HlMme77I6pZ8U256-2B2cMJuELsu3JN3YM2Efh4,144
 fmu/settings/__init__.py,sha256=CkEE7al_uBCQO1lxBKN5LzyCwzzH5Aq6kkEIR7f-zTw,336
-fmu/settings/_fmu_dir.py,sha256=Br_hcfAXshiuDyWqG_qx5VXFpsCBJO1XDMPzdxxesoE,10684
-fmu/settings/_init.py,sha256=5CT7tV2XHz5wuLh97XozyLiKpwogrsfjpxm2dpn7KWE,4097
+fmu/settings/_fmu_dir.py,sha256=XeZjec78q0IUOpBq-VMkKoWtzXwBeQi2qWRIh_SIFwU,10859
+fmu/settings/_global_config.py,sha256=tYSQH_48cknaEeo8C_uraEaPXZrrN7cHYZOCX9G39yM,8916
+fmu/settings/_init.py,sha256=ucueS0BlEsM3MkX7IaRISloH4vF7-_ZKSphrORbHgJ4,4381
 fmu/settings/_logging.py,sha256=nEdmZlNCBsB1GfDmFMKCjZmeuRp3CRlbz1EYUemc95Y,1104
-fmu/settings/_version.py,sha256=e8NqPtZ8fggRgk3GPrqZ_U_BDV8aSULw1u_Gn9NNbnk,704
+fmu/settings/_version.py,sha256=fvHpBU3KZKRinkriKdtAt3crenOyysELF-M9y3ozg3U,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/lock_manager.py,sha256=_xzSJNF_qcpKpo8AxMfEgOhPxKXl3fZ2lRi0_y2eUEg,9206
-fmu/settings/_resources/pydantic_resource_manager.py,sha256=NV9qGnKaZ2RYt6o2NMaHvKyiZDIsxwD5y3y2a6QQtHw,3555
+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=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.3.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-fmu_settings-0.3.2.dist-info/METADATA,sha256=CC-jegtLPAS2vpUajvXTd3D_Fyow5q62Dwy4WDH4ypA,2024
-fmu_settings-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fmu_settings-0.3.2.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
-fmu_settings-0.3.2.dist-info/RECORD,,
+fmu_settings-0.5.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+fmu_settings-0.5.0.dist-info/METADATA,sha256=5Ff9Xfr_KsWUptwWt4HlKIkfnmME7D2UqclD-qzgrSo,2116
+fmu_settings-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fmu_settings-0.5.0.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
+fmu_settings-0.5.0.dist-info/RECORD,,