fmu-settings 0.5.4__tar.gz → 0.6.1__tar.gz

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/PKG-INFO

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

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/src/fmu/settings/_fmu_dir.py

@@ -4,12 +4,13 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, Final, Self, TypeAlias, cast
 
 from ._logging import null_logger
+from ._readme_texts import PROJECT_README_CONTENT, USER_README_CONTENT
 from ._resources.cache_manager import CacheManager
 from ._resources.config_managers import (
     ProjectConfigManager,
     UserConfigManager,
 )
-from ._resources.lock_manager import LockManager
+from ._resources.lock_manager import DEFAULT_LOCK_TIMEOUT, LockManager
 from .models.project_config import ProjectConfig
 from .models.user_config import UserConfig
 
@@ -24,13 +25,22 @@ class FMUDirectoryBase:
     config: FMUConfigManager
     _lock: LockManager
     _cache_manager: CacheManager
-
-    def __init__(self: Self, base_path: str | Path) -> None:
+    _README_CONTENT: str = ""
+
+    def __init__(
+        self: Self,
+        base_path: str | Path,
+        cache_revisions: int = CacheManager.MIN_REVISIONS,
+        *,
+        lock_timeout_seconds: int = DEFAULT_LOCK_TIMEOUT,
+    ) -> None:
         """Initializes access to a .fmu directory.
 
         Args:
             base_path: The directory containing the .fmu directory or one of its parent
                 dirs
+            cache_revisions: Number of revisions to retain in the cache. Minimum is 5.
+            lock_timeout_seconds: Lock expiration time in seconds. Default 20 minutes.
 
         Raises:
             FileExistsError: If .fmu exists but is not a directory
@@ -39,8 +49,8 @@ class FMUDirectoryBase:
         """
         self.base_path = Path(base_path).resolve()
         logger.debug(f"Initializing FMUDirectory from '{base_path}'")
-        self._lock = LockManager(self)
-        self._cache_manager = CacheManager(self, max_revisions=5)
+        self._lock = LockManager(self, timeout_seconds=lock_timeout_seconds)
+        self._cache_manager = CacheManager(self, max_revisions=cache_revisions)
 
         fmu_dir = self.base_path / ".fmu"
         if fmu_dir.exists():
@@ -72,8 +82,15 @@ class FMUDirectoryBase:
 
     @cache_max_revisions.setter
     def cache_max_revisions(self: Self, value: int) -> None:
-        """Update the retention limit for revision snapshots."""
-        self._cache_manager.max_revisions = value
+        """Update the retention limit for revision snapshots.
+
+        Args:
+            value: The new maximum number of revisions to retain. Minimum value is 5.
+                Values below 5 are set to 5.
+        """
+        clamped_value = max(CacheManager.MIN_REVISIONS, value)
+        self._cache_manager.max_revisions = clamped_value
+        self.set_config_value("cache_max_revisions", clamped_value)
 
     def get_config_value(self: Self, key: str, default: Any = None) -> Any:
         """Gets a configuration value by key.
@@ -230,15 +247,59 @@ class FMUDirectoryBase:
         """
         return self.get_file_path(relative_path).exists()
 
+    def restore(self: Self) -> None:
+        """Attempt to reconstruct missing .fmu files from in-memory state."""
+        if not self.path.exists():
+            self.path.mkdir(parents=True, exist_ok=True)
+            logger.info("Recreated missing .fmu directory at %s", self.path)
+
+        readme_path = self.get_file_path("README")
+        if self._README_CONTENT and not readme_path.exists():
+            self.write_text_file("README", self._README_CONTENT)
+            logger.info("Restored README at %s", readme_path)
+
+        config_path = self.config.path
+        if not config_path.exists():
+            cached_model = getattr(self.config, "_cache", None)
+            if cached_model is not None:
+                self.config.save(cached_model)
+                logger.info("Restored config.json from cached model at %s", config_path)
+            else:
+                self.config.reset()
+                logger.info("Restored config.json from defaults at %s", config_path)
+
 
 class ProjectFMUDirectory(FMUDirectoryBase):
     if TYPE_CHECKING:
         config: ProjectConfigManager
 
-    def __init__(self, base_path: str | Path) -> None:
-        """Initializes a project-based .fmu directory."""
+    _README_CONTENT: str = PROJECT_README_CONTENT
+
+    def __init__(
+        self: Self,
+        base_path: str | Path,
+        *,
+        lock_timeout_seconds: int = DEFAULT_LOCK_TIMEOUT,
+    ) -> None:
+        """Initializes a project-based .fmu directory.
+
+        Args:
+            base_path: Project directory containing the .fmu folder.
+            lock_timeout_seconds: Lock expiration time in seconds. Default 20 minutes.
+        """
         self.config = ProjectConfigManager(self)
-        super().__init__(base_path)
+        super().__init__(
+            base_path,
+            CacheManager.MIN_REVISIONS,
+            lock_timeout_seconds=lock_timeout_seconds,
+        )
+        try:
+            max_revisions = self.config.get(
+                "cache_max_revisions", CacheManager.MIN_REVISIONS
+            )
+            self._cache_manager.max_revisions = max_revisions
+        except FileNotFoundError:
+            pass
 
     def update_config(self: Self, updates: dict[str, Any]) -> ProjectConfig:
         """Updates multiple configuration values at once.
@@ -286,11 +347,17 @@ class ProjectFMUDirectory(FMUDirectoryBase):
         return None
 
     @classmethod
-    def find_nearest(cls: type[Self], start_path: str | Path = ".") -> Self:
+    def find_nearest(
+        cls: type[Self],
+        start_path: str | Path = ".",
+        *,
+        lock_timeout_seconds: int = DEFAULT_LOCK_TIMEOUT,
+    ) -> Self:
         """Factory method to find and open the nearest .fmu directory.
 
         Args:
             start_path: Path to start searching from. Default current working director
+            lock_timeout_seconds: Lock expiration time in seconds. Default 20 minutes.
 
         Returns:
             FMUDirectory instance
@@ -302,17 +369,38 @@ class ProjectFMUDirectory(FMUDirectoryBase):
         fmu_dir_path = cls.find_fmu_directory(start_path)
         if fmu_dir_path is None:
             raise FileNotFoundError(f"No .fmu directory found at or above {start_path}")
-        return cls(fmu_dir_path.parent)
+        return cls(fmu_dir_path.parent, lock_timeout_seconds=lock_timeout_seconds)
 
 
 class UserFMUDirectory(FMUDirectoryBase):
     if TYPE_CHECKING:
         config: UserConfigManager
 
-    def __init__(self) -> None:
-        """Initializes a project-based .fmu directory."""
+    _README_CONTENT: str = USER_README_CONTENT
+
+    def __init__(
+        self: Self,
+        *,
+        lock_timeout_seconds: int = DEFAULT_LOCK_TIMEOUT,
+    ) -> None:
+        """Initializes a user .fmu directory.
+
+        Args:
+            lock_timeout_seconds: Lock expiration time in seconds. Default 20 minutes.
+        """
         self.config = UserConfigManager(self)
-        super().__init__(Path.home())
+        super().__init__(
+            Path.home(),
+            CacheManager.MIN_REVISIONS,
+            lock_timeout_seconds=lock_timeout_seconds,
+        )
+        try:
+            max_revisions = self.config.get(
+                "cache_max_revisions", CacheManager.MIN_REVISIONS
+            )
+            self._cache_manager.max_revisions = max_revisions
+        except FileNotFoundError:
+            pass
 
     def update_config(self: Self, updates: dict[str, Any]) -> UserConfig:
         """Updates multiple configuration values at once.
@@ -330,12 +418,17 @@ class UserFMUDirectory(FMUDirectoryBase):
         return cast("UserConfig", super().update_config(updates))
 
 
-def get_fmu_directory(base_path: str | Path) -> ProjectFMUDirectory:
+def get_fmu_directory(
+    base_path: str | Path,
+    *,
+    lock_timeout_seconds: int = DEFAULT_LOCK_TIMEOUT,
+) -> ProjectFMUDirectory:
     """Initializes access to a .fmu directory.
 
     Args:
         base_path: The directory containing the .fmu directory or one of its parent
                    dirs
+        lock_timeout_seconds: Lock expiration time in seconds. Default 20 minutes.
 
     Returns:
         FMUDirectory instance
@@ -346,14 +439,19 @@ def get_fmu_directory(base_path: str | Path) -> ProjectFMUDirectory:
         PermissionError: If lacking permissions to read/write to the directory
 
     """
-    return ProjectFMUDirectory(base_path)
+    return ProjectFMUDirectory(base_path, lock_timeout_seconds=lock_timeout_seconds)
 
 
-def find_nearest_fmu_directory(start_path: str | Path = ".") -> ProjectFMUDirectory:
+def find_nearest_fmu_directory(
+    start_path: str | Path = ".",
+    *,
+    lock_timeout_seconds: int = DEFAULT_LOCK_TIMEOUT,
+) -> ProjectFMUDirectory:
     """Factory method to find and open the nearest .fmu directory.
 
     Args:
         start_path: Path to start searching from. Default current working directory
+        lock_timeout_seconds: Lock expiration time in seconds. Default 20 minutes.
 
     Returns:
         FMUDirectory instance
@@ -361,4 +459,6 @@ def find_nearest_fmu_directory(start_path: str | Path = ".") -> ProjectFMUDirect
     Raises:
         FileNotFoundError: If no .fmu directory is found
     """
-    return ProjectFMUDirectory.find_nearest(start_path)
+    return ProjectFMUDirectory.find_nearest(
+        start_path, lock_timeout_seconds=lock_timeout_seconds
+    )

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/src/fmu/settings/_init.py

@@ -1,43 +1,18 @@
 """Initializes the .fmu directory."""
 
 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 ._readme_texts import PROJECT_README_CONTENT, USER_README_CONTENT
+from ._resources.lock_manager import DEFAULT_LOCK_TIMEOUT
 from .models.project_config import ProjectConfig
 
 logger: Final = null_logger(__name__)
 
-_README = dedent("""\
-    This directory contains static configuration data for your FMU project.
-
-    You should *not* manually modify files within this directory. Doing so may
-    result in erroneous behavior or erroneous data in your FMU project.
-
-    Changes to data stored within this directory must happen through the FMU
-    Settings application.
-
-    Run `fmu-settings` to do this.
-""")
-
-_USER_README = dedent("""\
-    This directory contains static data and configuration elements used by some
-    components in FMU. It may also contains sensitive access tokens that should not be
-    shared with others.
-
-    You should *not* manually modify files within this directory. Doing so may
-    result in erroneous behavior by some FMU components.
-
-    Changes to data stored within this directory must happen through the FMU
-    Settings application.
-
-    Run `fmu-settings` to do this.
-""")
-
 
 def _create_fmu_directory(base_path: Path) -> None:
     """Creates the .fmu directory.
@@ -71,6 +46,8 @@ def init_fmu_directory(
     base_path: str | Path,
     config_data: ProjectConfig | dict[str, Any] | None = None,
     global_config: GlobalConfiguration | None = None,
+    *,
+    lock_timeout_seconds: int = DEFAULT_LOCK_TIMEOUT,
 ) -> ProjectFMUDirectory:
     """Creates and initializes a .fmu directory.
 
@@ -83,6 +60,7 @@ def init_fmu_directory(
           data.
         global_config: Optional GlobaConfiguration instance with existing global config
           data.
+        lock_timeout_seconds: Lock expiration time in seconds. Default 20 minutes.
 
     Returns:
         Instance of FMUDirectory
@@ -98,8 +76,11 @@ def init_fmu_directory(
 
     _create_fmu_directory(base_path)
 
-    fmu_dir = ProjectFMUDirectory(base_path)
-    fmu_dir.write_text_file("README", _README)
+    fmu_dir = ProjectFMUDirectory(
+        base_path,
+        lock_timeout_seconds=lock_timeout_seconds,
+    )
+    fmu_dir.write_text_file("README", PROJECT_README_CONTENT)
 
     fmu_dir.config.reset()
     if config_data:
@@ -115,9 +96,15 @@ def init_fmu_directory(
     return fmu_dir
 
 
-def init_user_fmu_directory() -> UserFMUDirectory:
+def init_user_fmu_directory(
+    *,
+    lock_timeout_seconds: int = DEFAULT_LOCK_TIMEOUT,
+) -> UserFMUDirectory:
     """Creates and initializes a user's $HOME/.fmu directory.
 
+    Args:
+        lock_timeout_seconds: Lock expiration time in seconds. Default 20 minutes.
+
     Returns:
         Instance of FMUDirectory
 
@@ -131,8 +118,8 @@ def init_user_fmu_directory() -> UserFMUDirectory:
 
     _create_fmu_directory(Path.home())
 
-    fmu_dir = UserFMUDirectory()
-    fmu_dir.write_text_file("README", _USER_README)
+    fmu_dir = UserFMUDirectory(lock_timeout_seconds=lock_timeout_seconds)
+    fmu_dir.write_text_file("README", USER_README_CONTENT)
 
     fmu_dir.config.reset()
     logger.debug(f"Successfully initialized .fmu directory at '{fmu_dir}'")

fmu_settings-0.6.1/src/fmu/settings/_readme_texts.py

@@ -0,0 +1,34 @@
+"""Shared README content for .fmu directories."""
+
+from textwrap import dedent
+from typing import Final
+
+PROJECT_README_CONTENT: Final[str] = dedent(
+    """\
+    This directory contains static configuration data for your FMU project.
+
+    You should *not* manually modify files within this directory. Doing so may
+    result in erroneous behavior or erroneous data in your FMU project.
+
+    Changes to data stored within this directory must happen through the FMU
+    Settings application.
+
+    Run `fmu-settings` to do this.
+    """
+)
+
+USER_README_CONTENT: Final[str] = dedent(
+    """\
+    This directory contains static data and configuration elements used by some
+    components in FMU. It may also contains sensitive access tokens that should not be
+    shared with others.
+
+    You should *not* manually modify files within this directory. Doing so may
+    result in erroneous behavior by some FMU components.
+
+    Changes to data stored within this directory must happen through the FMU
+    Settings application.
+
+    Run `fmu-settings` to do this.
+    """
+)

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/src/fmu/settings/_resources/cache_manager.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from datetime import UTC, datetime
 from pathlib import Path
-from typing import TYPE_CHECKING, Final, Self
+from typing import TYPE_CHECKING, ClassVar, Final, Self
 from uuid import uuid4
 
 from fmu.settings._logging import null_logger
@@ -25,6 +25,8 @@ _CACHEDIR_TAG_CONTENT: Final = (
 class CacheManager:
     """Stores complete file revisions under the `.fmu/cache` tree."""
 
+    MIN_REVISIONS: ClassVar[int] = 5
+
     def __init__(
         self: Self,
         fmu_dir: FMUDirectoryBase,
@@ -35,10 +37,11 @@ class CacheManager:
         Args:
             fmu_dir: The FMUDirectory instance.
             max_revisions: Maximum number of revisions to retain. Default is 5.
+                Values below 5 are set to 5.
         """
         self._fmu_dir = fmu_dir
         self._cache_root = Path("cache")
-        self._max_revisions = max(0, max_revisions)
+        self._max_revisions = max(self.MIN_REVISIONS, max_revisions)
 
     @property
     def max_revisions(self: Self) -> int:
@@ -47,8 +50,13 @@ class CacheManager:
 
     @max_revisions.setter
     def max_revisions(self: Self, value: int) -> None:
-        """Update the per-resource revision retention."""
-        self._max_revisions = max(0, value)
+        """Update the per-resource revision retention.
+
+        Args:
+            value: The new maximum number of revisions. Minimum value is 5.
+                Values below 5 are set to 5.
+        """
+        self._max_revisions = max(self.MIN_REVISIONS, value)
 
     def store_revision(
         self: Self,
@@ -65,12 +73,8 @@ class CacheManager:
             encoding: Encoding used when persisting the snapshot. Defaults to UTF-8.
 
         Returns:
-            Absolute filesystem path to the stored snapshot, or ``None`` if caching is
-            disabled (``max_revisions`` equals zero).
+            Absolute filesystem path to the stored snapshot.
         """
-        if self.max_revisions == 0:
-            return None
-
         resource_file_path = Path(resource_file_path)
         cache_dir = self._ensure_resource_cache_dir(resource_file_path)
         snapshot_name = self._snapshot_filename(resource_file_path)

{fmu_settings-0.5.4 → fmu_settings-0.6.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.5.4'
-__version_tuple__ = version_tuple = (0, 5, 4)
+__version__ = version = '0.6.1'
+__version_tuple__ = version_tuple = (0, 6, 1)
 
-__commit_id__ = commit_id = 'g118a9d2da'
+__commit_id__ = commit_id = 'gb2f5d6b1e'

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/src/fmu/settings/models/project_config.py

@@ -23,6 +23,7 @@ class ProjectConfig(ResettableBaseModel):
     masterdata: Masterdata | None = Field(default=None)
     model: Model | None = Field(default=None)
     access: Access | None = Field(default=None)
+    cache_max_revisions: int = Field(default=5, ge=5)
 
     @classmethod
     def reset(cls: type[Self]) -> Self:
@@ -38,4 +39,5 @@ class ProjectConfig(ResettableBaseModel):
             masterdata=None,
             model=None,
             access=None,
+            cache_max_revisions=5,
         )

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/src/fmu/settings/models/user_config.py

@@ -10,6 +10,7 @@ import annotated_types
 from pydantic import (
     AwareDatetime,
     BaseModel,
+    Field,
     SecretStr,
     field_serializer,
     field_validator,
@@ -42,6 +43,7 @@ class UserConfig(ResettableBaseModel):
 
     version: VersionStr
     created_at: AwareDatetime
+    cache_max_revisions: int = Field(default=5, ge=5)
     user_api_keys: UserAPIKeys
     recent_project_directories: RecentProjectDirectories
 
@@ -51,6 +53,7 @@ class UserConfig(ResettableBaseModel):
         return cls(
             version=__version__,
             created_at=datetime.now(UTC),
+            cache_max_revisions=5,
             user_api_keys=UserAPIKeys(),
             recent_project_directories=[],
         )

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/src/fmu_settings.egg-info/PKG-INFO

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

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/src/fmu_settings.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ src/fmu/settings/_fmu_dir.py
 src/fmu/settings/_global_config.py
 src/fmu/settings/_init.py
 src/fmu/settings/_logging.py
+src/fmu/settings/_readme_texts.py
 src/fmu/settings/_version.py
 src/fmu/settings/py.typed
 src/fmu/settings/types.py

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/tests/conftest.py

@@ -39,6 +39,7 @@ def config_dict(unix_epoch_utc: datetime) -> dict[str, Any]:
         "version": __version__,
         "created_at": unix_epoch_utc,
         "created_by": "user",
+        "cache_max_revisions": 5,
         "masterdata": None,
         "model": None,
         "access": None,
@@ -283,6 +284,7 @@ def config_dict_with_masterdata(
         "version": __version__,
         "created_at": unix_epoch_utc,
         "created_by": "user",
+        "cache_max_revisions": 5,
         "masterdata": masterdata_dict,
         "model": model_dict,
     }
@@ -308,6 +310,7 @@ def user_config_dict(unix_epoch_utc: datetime) -> dict[str, Any]:
     return {
         "version": __version__,
         "created_at": unix_epoch_utc,
+        "cache_max_revisions": 5,
         "user_api_keys": {
             "smda_subscription": None,
         },

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/tests/test_fmu_dir.py

@@ -1,6 +1,8 @@
 """Tests for the ProjectFMUDirectory class."""
 
+import inspect
 import json
+import shutil
 from pathlib import Path
 from unittest.mock import patch
 
@@ -8,8 +10,13 @@ import pytest
 from pytest import MonkeyPatch
 
 from fmu.settings import __version__, find_nearest_fmu_directory, get_fmu_directory
-from fmu.settings._fmu_dir import ProjectFMUDirectory, UserFMUDirectory
-from fmu.settings._resources.lock_manager import LockManager
+from fmu.settings._fmu_dir import (
+    FMUDirectoryBase,
+    ProjectFMUDirectory,
+    UserFMUDirectory,
+)
+from fmu.settings._readme_texts import PROJECT_README_CONTENT, USER_README_CONTENT
+from fmu.settings._resources.lock_manager import DEFAULT_LOCK_TIMEOUT, LockManager
 
 
 def test_init_existing_directory(fmu_dir: ProjectFMUDirectory) -> None:
@@ -390,3 +397,77 @@ def test_acquire_lock_on_user_fmu(
     assert user_fmu_dir._lock.is_acquired()
     assert user_fmu_dir._lock.exists
     assert (user_fmu_dir.path / ".lock").exists()
+
+
+def test_restore_rebuilds_project_fmu_from_cache(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Tests that restore should recreate missing files using cached config data."""
+    fmu_dir.update_config({"version": "123.4.5"})
+    cached_dump = json.loads((fmu_dir.path / "config.json").read_text())
+
+    shutil.rmtree(fmu_dir.path)
+    assert not fmu_dir.path.exists()
+
+    fmu_dir.restore()
+
+    assert fmu_dir.path.exists()
+    readme_path = fmu_dir.path / "README"
+    assert readme_path.exists()
+    assert readme_path.read_text() == PROJECT_README_CONTENT
+
+    restored_dump = json.loads((fmu_dir.path / "config.json").read_text())
+    assert restored_dump == cached_dump
+
+    cache_dir = fmu_dir.path / "cache" / "config"
+    assert cache_dir.is_dir()
+    assert any(cache_dir.iterdir())
+
+
+def test_restore_resets_when_cache_missing(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Tests that restore should fall back to reset when no cached config exists."""
+    fmu_dir.config._cache = None
+    shutil.rmtree(fmu_dir.path)
+    assert not fmu_dir.path.exists()
+
+    with patch.object(
+        fmu_dir.config, "reset", wraps=fmu_dir.config.reset
+    ) as mock_reset:
+        fmu_dir.restore()
+
+    mock_reset.assert_called_once()
+    assert fmu_dir.path.exists()
+    readme_path = fmu_dir.path / "README"
+    assert readme_path.exists()
+    assert readme_path.read_text() == PROJECT_README_CONTENT
+    assert (fmu_dir.config.path).exists()
+
+
+def test_restore_rebuilds_user_fmu(user_fmu_dir: UserFMUDirectory) -> None:
+    """Tests that user FMU restore should recreate missing files using cached state."""
+    cached_dump = json.loads((user_fmu_dir.path / "config.json").read_text())
+
+    shutil.rmtree(user_fmu_dir.path)
+    assert not user_fmu_dir.path.exists()
+
+    user_fmu_dir.restore()
+
+    assert user_fmu_dir.path.exists()
+    readme_path = user_fmu_dir.path / "README"
+    assert readme_path.exists()
+    assert readme_path.read_text() == USER_README_CONTENT
+
+    restored_dump = json.loads((user_fmu_dir.path / "config.json").read_text())
+    assert restored_dump == cached_dump
+
+
+def test_fmu_directory_base_exposes_lock_timeout_kwarg() -> None:
+    """Tests that the kw-only lock timeout argument remains available."""
+    signature = inspect.signature(FMUDirectoryBase.__init__)
+    lock_timeout = signature.parameters.get("lock_timeout_seconds")
+
+    assert lock_timeout is not None, "lock_timeout_seconds kwarg missing from base init"
+    assert lock_timeout.kind is inspect.Parameter.KEYWORD_ONLY
+    assert lock_timeout.default == DEFAULT_LOCK_TIMEOUT

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/tests/test_init.py

@@ -11,12 +11,11 @@ import pytest
 from fmu.settings import __version__
 from fmu.settings._global_config import find_global_config
 from fmu.settings._init import (
-    _README,
-    _USER_README,
     _create_fmu_directory,
     init_fmu_directory,
     init_user_fmu_directory,
 )
+from fmu.settings._readme_texts import PROJECT_README_CONTENT, USER_README_CONTENT
 from fmu.settings.models.project_config import ProjectConfig
 from fmu.settings.models.user_config import UserConfig
 
@@ -128,7 +127,7 @@ def test_readme_is_written(tmp_path: Path, config_model: ProjectConfig) -> None:
 
     readme = fmu_dir.path / "README"
     assert readme.exists()
-    assert readme.read_text() == _README
+    assert readme.read_text() == PROJECT_README_CONTENT
 
 
 def test_init_user_fmu_directory(
@@ -178,4 +177,4 @@ def test_user_readme_is_written(tmp_path: Path, config_model: ProjectConfig) ->
 
     readme = fmu_dir.path / "README"
     assert readme.exists()
-    assert readme.read_text() == _USER_README
+    assert readme.read_text() == USER_README_CONTENT

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/tests/test_resources/test_cache_manager.py

@@ -5,7 +5,10 @@ from __future__ import annotations
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from fmu.settings._resources.cache_manager import _CACHEDIR_TAG_CONTENT, CacheManager
+from fmu.settings._resources.cache_manager import (
+    _CACHEDIR_TAG_CONTENT,
+    CacheManager,
+)
 
 if TYPE_CHECKING:
     import pytest
@@ -84,8 +87,9 @@ def test_cache_manager_trim_handles_missing_files(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     """Trimming gracefully handles concurrent removals."""
-    manager = CacheManager(fmu_dir, max_revisions=1)
-    manager.store_revision("foo.json", "first")
+    manager = CacheManager(fmu_dir, max_revisions=CacheManager.MIN_REVISIONS)
+    for i in range(CacheManager.MIN_REVISIONS + 2):
+        manager.store_revision("foo.json", f"content_{i}")
 
     original_unlink = Path.unlink
 
@@ -98,19 +102,7 @@ def test_cache_manager_trim_handles_missing_files(
 
     monkeypatch.setattr(Path, "unlink", flaky_unlink)
 
-    manager.store_revision("foo.json", "second")
+    manager.store_revision("foo.json", "final")
 
     config_cache = fmu_dir.path / "cache" / "foo"
-    assert getattr(flaky_unlink, "raised", False) is True
-    assert len(_read_snapshot_names(config_cache)) == 1
-
-
-def test_cache_manager_max_revisions_zero_skips_storage(
-    fmu_dir: ProjectFMUDirectory,
-) -> None:
-    """Storing with zero retention should return None and create nothing."""
-    manager = CacheManager(fmu_dir, max_revisions=0)
-    result = manager.store_revision("foo.json", "data")
-    assert result is None
-    cache_dir = fmu_dir.path / "cache" / "foo"
-    assert not cache_dir.exists()
+    assert len(_read_snapshot_names(config_cache)) == CacheManager.MIN_REVISIONS

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/tests/test_resources/test_lock_manager.py

@@ -523,6 +523,24 @@ def test_refresh_without_lock_file(
     assert fmu_dir._lock.is_acquired() is False
 
 
+def test_refresh_missing_lock_releases_owned_lock(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Tests refresh releases cached state when lock file is missing."""
+    lock = LockManager(fmu_dir)
+    lock.acquire()
+    lock.path.unlink()
+
+    with (
+        patch.object(lock, "is_acquired", return_value=True),
+        patch.object(lock, "release") as mock_release,
+        pytest.raises(LockNotFoundError, match="lock file does not exist"),
+    ):
+        lock.refresh()
+
+    mock_release.assert_called_once()
+
+
 def test_refresh_without_owning_lock(
     fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
 ) -> None:

{fmu_settings-0.5.4 → fmu_settings-0.6.1}/tests/test_resources/test_resource_managers.py

@@ -10,7 +10,6 @@ import pytest
 from pydantic import BaseModel
 
 from fmu.settings._fmu_dir import ProjectFMUDirectory
-from fmu.settings._resources.cache_manager import CacheManager
 from fmu.settings._resources.lock_manager import LockManager
 from fmu.settings._resources.pydantic_resource_manager import PydanticResourceManager
 
@@ -230,57 +229,28 @@ def test_pydantic_resource_manager_save_stores_revision_when_enabled(
 
 
 def test_pydantic_resource_manager_revision_cache_trims_excess(
-    fmu_dir: ProjectFMUDirectory, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """Revision caching should retain only the configured number of snapshots."""
-    original_limit = fmu_dir.cache_max_revisions
-    fmu_dir.cache_max_revisions = 2
-    try:
-        sequence = iter(["rev1.json", "rev2.json", "rev3.json"])
-        monkeypatch.setattr(
-            CacheManager,
-            "_snapshot_filename",
-            lambda self, config_file_path: next(sequence),
-        )
-
-        a = AManager(fmu_dir)
-        a.save(A(foo="one"))
-        a.save(A(foo="two"))
-        a.save(A(foo="three"))
-    finally:
-        fmu_dir.cache_max_revisions = original_limit
-
-    config_cache = fmu_dir.path / "cache" / "foo"
-    snapshots = sorted(p.name for p in config_cache.iterdir())
-    assert snapshots == ["rev2.json", "rev3.json"]
-
-    assert (
-        json.loads((config_cache / "rev3.json").read_text(encoding="utf-8"))["foo"]
-        == "three"
-    )
-
-
-def test_pydantic_resource_manager_respects_retention_setting(
     fmu_dir: ProjectFMUDirectory,
 ) -> None:
-    """Saving uses the cache manager retention setting."""
+    """Revision caching should retain only the configured number of snapshots."""
     original_limit = fmu_dir.cache_max_revisions
-    fmu_dir.cache_max_revisions = 3
+    fmu_dir.cache_max_revisions = 5
     try:
         a = AManager(fmu_dir)
         a.save(A(foo="one"))
         a.save(A(foo="two"))
         a.save(A(foo="three"))
         a.save(A(foo="four"))
+        a.save(A(foo="five"))
+        a.save(A(foo="six"))
     finally:
         fmu_dir.cache_max_revisions = original_limit
 
     config_cache = fmu_dir.path / "cache" / "foo"
     snapshots = sorted(p.name for p in config_cache.iterdir())
-    assert len(snapshots) == 3  # noqa: PLR2004
+    assert len(snapshots) == 5  # noqa: PLR2004
 
     contents = [
         json.loads((config_cache / name).read_text(encoding="utf-8"))["foo"]
         for name in snapshots
     ]
-    assert contents == ["two", "three", "four"]
+    assert contents == ["two", "three", "four", "five", "six"]