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

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

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

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

@@ -1,9 +1,10 @@
 """Main interface for working with .fmu directory."""
 
 from pathlib import Path
-from typing import Any, Final, Self, TypeAlias, cast
+from typing import TYPE_CHECKING, Any, Final, Self, TypeAlias, cast
 
 from ._logging import null_logger
+from ._resources.cache_manager import CacheManager
 from ._resources.config_managers import (
     ProjectConfigManager,
     UserConfigManager,
@@ -22,6 +23,7 @@ class FMUDirectoryBase:
 
     config: FMUConfigManager
     _lock: LockManager
+    _cache_manager: CacheManager
 
     def __init__(self: Self, base_path: str | Path) -> None:
         """Initializes access to a .fmu directory.
@@ -38,6 +40,7 @@ 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)
 
         fmu_dir = self.base_path / ".fmu"
         if fmu_dir.exists():
@@ -57,6 +60,21 @@ class FMUDirectoryBase:
         """Returns the path to the .fmu directory."""
         return self._path
 
+    @property
+    def cache(self: Self) -> CacheManager:
+        """Access the cache manager."""
+        return self._cache_manager
+
+    @property
+    def cache_max_revisions(self: Self) -> int:
+        """Current retention limit for revision snapshots."""
+        return self._cache_manager.max_revisions
+
+    @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
+
     def get_config_value(self: Self, key: str, default: Any = None) -> Any:
         """Gets a configuration value by key.
 
@@ -214,7 +232,8 @@ class FMUDirectoryBase:
 
 
 class ProjectFMUDirectory(FMUDirectoryBase):
-    config: ProjectConfigManager
+    if TYPE_CHECKING:
+        config: ProjectConfigManager
 
     def __init__(self, base_path: str | Path) -> None:
         """Initializes a project-based .fmu directory."""
@@ -287,7 +306,8 @@ class ProjectFMUDirectory(FMUDirectoryBase):
 
 
 class UserFMUDirectory(FMUDirectoryBase):
-    config: UserConfigManager
+    if TYPE_CHECKING:
+        config: UserConfigManager
 
     def __init__(self) -> None:
         """Initializes a project-based .fmu directory."""

fmu_settings-0.5.4/src/fmu/settings/_resources/cache_manager.py

@@ -0,0 +1,149 @@
+"""Utilities for storing revision snapshots of .fmu files."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Final, Self
+from uuid import uuid4
+
+from fmu.settings._logging import null_logger
+
+if TYPE_CHECKING:
+    from fmu.settings._fmu_dir import FMUDirectoryBase
+
+logger: Final = null_logger(__name__)
+
+_CACHEDIR_TAG_CONTENT: Final = (
+    "Signature: 8a477f597d28d172789f06886806bc55\n"
+    "# This directory contains cached FMU files.\n"
+    "# For information about cache directory tags, see:\n"
+    "#	https://bford.info/cachedir/spec.html"
+)
+
+
+class CacheManager:
+    """Stores complete file revisions under the `.fmu/cache` tree."""
+
+    def __init__(
+        self: Self,
+        fmu_dir: FMUDirectoryBase,
+        max_revisions: int = 5,
+    ) -> None:
+        """Initialize the cache manager.
+
+        Args:
+            fmu_dir: The FMUDirectory instance.
+            max_revisions: Maximum number of revisions to retain. Default is 5.
+        """
+        self._fmu_dir = fmu_dir
+        self._cache_root = Path("cache")
+        self._max_revisions = max(0, max_revisions)
+
+    @property
+    def max_revisions(self: Self) -> int:
+        """Maximum number of revisions retained per resource."""
+        return self._max_revisions
+
+    @max_revisions.setter
+    def max_revisions(self: Self, value: int) -> None:
+        """Update the per-resource revision retention."""
+        self._max_revisions = max(0, value)
+
+    def store_revision(
+        self: Self,
+        resource_file_path: Path | str,
+        content: str,
+        encoding: str = "utf-8",
+    ) -> Path | None:
+        """Write a full snapshot of the resource file to the cache directory.
+
+        Args:
+            resource_file_path: Relative path within the ``.fmu`` directory (e.g.,
+                ``config.json``) of the resource file being cached.
+            content: Serialized payload to store.
+            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).
+        """
+        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)
+        snapshot_path = cache_dir / snapshot_name
+
+        cache_relative = self._cache_root / resource_file_path.stem
+        self._fmu_dir.write_text_file(
+            cache_relative / snapshot_name, content, encoding=encoding
+        )
+        logger.debug("Stored revision snapshot at %s", snapshot_path)
+
+        self._trim(cache_dir)
+        return snapshot_path
+
+    def list_revisions(self: Self, resource_file_path: Path | str) -> list[Path]:
+        """List existing snapshots for a resource file, sorted oldest to newest.
+
+        Args:
+            resource_file_path: Relative path within the ``.fmu`` directory (e.g.,
+                ``config.json``) whose cache entries should be listed.
+
+        Returns:
+            A list of absolute `Path` objects sorted oldest to newest.
+        """
+        resource_file_path = Path(resource_file_path)
+        cache_relative = self._cache_root / resource_file_path.stem
+        if not self._fmu_dir.file_exists(cache_relative):
+            return []
+        cache_dir = self._fmu_dir.get_file_path(cache_relative)
+
+        revisions = [p for p in cache_dir.iterdir() if p.is_file()]
+        revisions.sort(key=lambda path: path.name)
+        return revisions
+
+    def _ensure_resource_cache_dir(self: Self, resource_file_path: Path) -> Path:
+        """Create (if needed) and return the cache directory for resource file."""
+        self._cache_root_path(create=True)
+        resource_cache_dir_relative = self._cache_root / resource_file_path.stem
+        return self._fmu_dir.ensure_directory(resource_cache_dir_relative)
+
+    def _cache_root_path(self: Self, create: bool) -> Path:
+        """Resolve the cache root, creating it and the cachedir tag if requested."""
+        if create:
+            cache_root = self._fmu_dir.ensure_directory(self._cache_root)
+            self._ensure_cachedir_tag()
+            return cache_root
+
+        return self._fmu_dir.get_file_path(self._cache_root)
+
+    def _ensure_cachedir_tag(self: Self) -> None:
+        """Ensure the cache root complies with the Cachedir specification."""
+        tag_path_relative = self._cache_root / "CACHEDIR.TAG"
+        if self._fmu_dir.file_exists(tag_path_relative):
+            return
+        self._fmu_dir.write_text_file(tag_path_relative, _CACHEDIR_TAG_CONTENT)
+
+    def _snapshot_filename(self: Self, resource_file_path: Path) -> str:
+        """Generate a timestamped filename for the next snapshot."""
+        timestamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%S.%fZ")
+        suffix = resource_file_path.suffix or ".txt"
+        token = uuid4().hex[:8]
+        return f"{timestamp}-{token}{suffix}"
+
+    def _trim(self: Self, cache_dir: Path) -> None:
+        """Remove the oldest snapshots until the retention limit is respected."""
+        revisions = [p for p in cache_dir.iterdir() if p.is_file()]
+        if len(revisions) <= self.max_revisions:
+            return
+
+        revisions.sort(key=lambda path: path.name)
+        excess = len(revisions) - self.max_revisions
+        for old_revision in revisions[:excess]:
+            try:
+                old_revision.unlink()
+            except FileNotFoundError:
+                continue

{fmu_settings-0.5.2 → fmu_settings-0.5.4}/src/fmu/settings/_resources/lock_manager.py

@@ -32,9 +32,15 @@ class LockError(Exception):
     """Raised when the lock cannot be acquired."""
 
 
+class LockNotFoundError(FileNotFoundError):
+    """Raised when the lock cannot be found."""
+
+
 class LockManager(PydanticResourceManager[LockInfo]):
     """Manages the .lock file."""
 
+    cache_enabled: bool = False
+
     def __init__(
         self: Self,
         fmu_dir: FMUDirectoryBase,
@@ -82,7 +88,7 @@ class LockManager(PydanticResourceManager[LockInfo]):
                 return
 
             if not wait:
-                lock_info = self._safe_load()
+                lock_info = self.safe_load()
                 if lock_info:
                     raise LockError(
                         f"Lock file is held by {lock_info.user}@{lock_info.hostname} "
@@ -152,12 +158,16 @@ class LockManager(PydanticResourceManager[LockInfo]):
             with contextlib.suppress(OSError):
                 temp_path.unlink()
 
-    def is_locked(self: Self) -> bool:
+    def is_locked(self: Self, *, propagate_errors: bool = False) -> bool:
         """Returns whether or not the lock is locked by anyone.
 
         This does a force load on the lock file.
         """
-        lock_info = self._safe_load(force=True)
+        lock_info = (
+            self.load(force=True, store_cache=False)
+            if propagate_errors
+            else self.safe_load(force=True, store_cache=False)
+        )
         if not lock_info:
             return False
         return time.time() < lock_info.expires_at
@@ -166,15 +176,16 @@ class LockManager(PydanticResourceManager[LockInfo]):
         """Returns whether or not the lock is currently acquired by this instance."""
         if self._cache is None or self._acquired_at is None:
             return False
-        return self._is_mine(self._cache) and not self._is_stale()
+
+        current_lock = self.safe_load(force=True, store_cache=False)
+        if current_lock is None:
+            return False
+
+        return self._is_mine(current_lock) 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
-
+        lock_info = self.safe_load(force=True, store_cache=False)
         if (
             self.exists
             and lock_info is not None
@@ -196,9 +207,9 @@ class LockManager(PydanticResourceManager[LockInfo]):
         if not self.exists:
             if self.is_acquired():
                 self.release()
-            raise LockError("Cannot refresh: lock file does not exist")
+            raise LockNotFoundError("Cannot refresh: lock file does not exist")
 
-        lock_info = self._safe_load()
+        lock_info = self.safe_load()
         if not lock_info or not self._is_mine(lock_info):
             raise LockError(
                 "Cannot refresh: lock file is held by another process or host."
@@ -210,7 +221,7 @@ class LockManager(PydanticResourceManager[LockInfo]):
     def release(self: Self) -> None:
         """Release the lock."""
         if self.exists:
-            lock_info = self._safe_load()
+            lock_info = self.safe_load()
             if lock_info and self._is_mine(lock_info):
                 with contextlib.suppress(ValueError):
                     self.path.unlink()
@@ -218,12 +229,15 @@ class LockManager(PydanticResourceManager[LockInfo]):
         self._acquired_at = None
         self._cache = None
 
-    def save(self: Self, data: LockInfo) -> None:
+    def save(
+        self: Self,
+        data: LockInfo,
+    ) -> None:
         """Save the lockfile in an NFS-atomic manner.
 
         This overrides save() from the Pydantic resource manager.
         """
-        lock_info = self._safe_load()
+        lock_info = self.safe_load()
         if not lock_info or not self._is_mine(lock_info):
             raise LockError(
                 "Failed to save lock: lock file is held by another process or host."
@@ -250,20 +264,22 @@ class LockManager(PydanticResourceManager[LockInfo]):
             and lock_info.acquired_at == self._acquired_at
         )
 
-    def _safe_load(self: Self, force: bool = False) -> LockInfo | None:
+    def safe_load(
+        self: Self, force: bool = False, store_cache: bool = False
+    ) -> LockInfo | None:
         """Load lock info, returning None if corrupted.
 
         Because this file does not exist in a static state, wrap around loading it.
         """
         try:
-            return self.load(force=force)
+            return self.load(force=force, store_cache=store_cache)
         except Exception:
             return None
 
     def _is_stale(self: Self, lock_info: LockInfo | None = None) -> bool:
         """Check if existing lock is stale (expired or process dead)."""
         if lock_info is None:
-            lock_info = self._safe_load()
+            lock_info = self.safe_load()
 
         if not lock_info:
             return True

{fmu_settings-0.5.2 → fmu_settings-0.5.4}/src/fmu/settings/_resources/pydantic_resource_manager.py

@@ -22,6 +22,8 @@ MutablePydanticResource = TypeVar("MutablePydanticResource", bound=ResettableBas
 class PydanticResourceManager(Generic[PydanticResource]):
     """Base class for managing resources represented by Pydantic models."""
 
+    cache_enabled: bool = True
+
     def __init__(
         self: Self, fmu_dir: FMUDirectoryBase, model_class: type[PydanticResource]
     ) -> None:
@@ -99,15 +101,22 @@ class PydanticResourceManager(Generic[PydanticResource]):
 
         return self._cache
 
-    def save(self: Self, model: PydanticResource) -> None:
+    def save(
+        self: Self,
+        model: PydanticResource,
+    ) -> None:
         """Save the Pydantic model to disk.
 
         Args:
-            model: Validated Pydantic model instance
+            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)
+
+        if self.cache_enabled and self.exists:
+            self.fmu_dir.cache.store_revision(self.relative_path, json_data)
+
         self._cache = model
 
 

{fmu_settings-0.5.2 → fmu_settings-0.5.4}/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.2'
-__version_tuple__ = version_tuple = (0, 5, 2)
+__version__ = version = '0.5.4'
+__version_tuple__ = version_tuple = (0, 5, 4)
 
-__commit_id__ = commit_id = 'g4490dbb9d'
+__commit_id__ = commit_id = 'g118a9d2da'

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

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

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

@@ -19,6 +19,7 @@ src/fmu/settings/_version.py
 src/fmu/settings/py.typed
 src/fmu/settings/types.py
 src/fmu/settings/_resources/__init__.py
+src/fmu/settings/_resources/cache_manager.py
 src/fmu/settings/_resources/config_managers.py
 src/fmu/settings/_resources/lock_manager.py
 src/fmu/settings/_resources/pydantic_resource_manager.py
@@ -37,6 +38,7 @@ tests/conftest.py
 tests/test_fmu_dir.py
 tests/test_global_config.py
 tests/test_init.py
+tests/test_resources/test_cache_manager.py
 tests/test_resources/test_lock_manager.py
 tests/test_resources/test_project_config.py
 tests/test_resources/test_resource_managers.py

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

@@ -110,6 +110,25 @@ def test_find_nearest_not_found(tmp_path: Path, monkeypatch: MonkeyPatch) -> Non
         ProjectFMUDirectory.find_nearest(tmp_path)
 
 
+def test_cache_property_returns_cached_manager(fmu_dir: ProjectFMUDirectory) -> None:
+    """Cache manager should be memoized and ready for use."""
+    cache = fmu_dir.cache
+
+    assert cache is fmu_dir.cache
+    assert fmu_dir._cache_manager is cache
+    assert cache.max_revisions == 5  # noqa: PLR2004
+
+
+def test_set_cache_max_revisions_updates_manager(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Changing retention should update the existing cache manager."""
+    cache = fmu_dir.cache
+    fmu_dir.cache_max_revisions = 7
+
+    assert cache.max_revisions == 7  # noqa: PLR2004
+
+
 def test_get_config_value(fmu_dir: ProjectFMUDirectory) -> None:
     """Tests get_config_value retrieves correctly from the config."""
     assert fmu_dir.get_config_value("version") == __version__

{fmu_settings-0.5.2 → fmu_settings-0.5.4}/tests/test_global_config.py

@@ -56,8 +56,8 @@ def test_validate_global_config_strict_model(
     generate_strict_valid_globalconfiguration: Callable[[], GlobalConfiguration],
 ) -> None:
     """Tests strict validation on 'model'."""
-    cfg = generate_strict_valid_globalconfiguration(  # type: ignore
-        model=fields.Model(name=name, revision=""),
+    cfg = generate_strict_valid_globalconfiguration(
+        model=fields.Model(name=name, revision=""),  # type: ignore
     )
     if valid:
         validate_global_configuration_strictly(cfg)  # Does not raise
@@ -75,8 +75,8 @@ def test_validate_global_config_strict_access(
     generate_strict_valid_globalconfiguration: Callable[[], GlobalConfiguration],
 ) -> None:
     """Tests strict validation on 'access'."""
-    cfg = generate_strict_valid_globalconfiguration(  # type: ignore
-        asset=fields.Asset(name=name),
+    cfg = generate_strict_valid_globalconfiguration(
+        asset=fields.Asset(name=name),  # type: ignore
     )
     if valid:
         validate_global_configuration_strictly(cfg)  # Does not raise
@@ -95,8 +95,8 @@ def test_validate_global_config_strict_smda_country_uuid(
     generate_strict_valid_globalconfiguration: Callable[[], GlobalConfiguration],
 ) -> None:
     """Tests strict validation on 'smda.country' uuids."""
-    cfg = generate_strict_valid_globalconfiguration(  # type: ignore
-        country_items=[
+    cfg = generate_strict_valid_globalconfiguration(
+        country_items=[  # type: ignore
             fields.CountryItem(identifier="bar", uuid=uuid),
             fields.CountryItem(identifier="foo", uuid=uuid4()),
         ],
@@ -118,8 +118,8 @@ def test_validate_global_config_strict_smda_discovery_identifier(
     generate_strict_valid_globalconfiguration: Callable[[], GlobalConfiguration],
 ) -> None:
     """Tests strict validation on 'smda.discovery' identifiers."""
-    cfg = generate_strict_valid_globalconfiguration(  # type: ignore
-        discovery_items=[
+    cfg = generate_strict_valid_globalconfiguration(
+        discovery_items=[  # type: ignore
             fields.DiscoveryItem(short_identifier=identifier, uuid=uuid4()),
             fields.DiscoveryItem(short_identifier="foo", uuid=uuid4()),
         ],
@@ -141,8 +141,8 @@ def test_validate_global_config_strict_smda_discovery_uuid(
     generate_strict_valid_globalconfiguration: Callable[[], GlobalConfiguration],
 ) -> None:
     """Tests strict validation on 'smda.discovery' uuids."""
-    cfg = generate_strict_valid_globalconfiguration(  # type: ignore
-        discovery_items=[
+    cfg = generate_strict_valid_globalconfiguration(
+        discovery_items=[  # type: ignore
             fields.DiscoveryItem(short_identifier="bar", uuid=uuid),
             fields.DiscoveryItem(short_identifier="foo", uuid=uuid4()),
         ],
@@ -164,8 +164,8 @@ def test_validate_global_config_strict_smda_field_identifier(
     generate_strict_valid_globalconfiguration: Callable[[], GlobalConfiguration],
 ) -> None:
     """Tests strict validation on 'smda.discovery' identifiers."""
-    cfg = generate_strict_valid_globalconfiguration(  # type: ignore
-        field_items=[
+    cfg = generate_strict_valid_globalconfiguration(
+        field_items=[  # type: ignore
             fields.FieldItem(identifier=identifier, uuid=uuid4()),
             fields.FieldItem(identifier="foo", uuid=uuid4()),
         ],
@@ -187,8 +187,8 @@ def test_validate_global_config_strict_smda_field_uuid(
     generate_strict_valid_globalconfiguration: Callable[[], GlobalConfiguration],
 ) -> None:
     """Tests strict validation on 'smda.discovery' uuids."""
-    cfg = generate_strict_valid_globalconfiguration(  # type: ignore
-        field_items=[
+    cfg = generate_strict_valid_globalconfiguration(
+        field_items=[  # type: ignore
             fields.FieldItem(identifier="bar", uuid=uuid),
             fields.FieldItem(identifier="foo", uuid=uuid4()),
         ],
@@ -210,8 +210,8 @@ def test_validate_global_config_strict_coordinate_system(
     generate_strict_valid_globalconfiguration: Callable[[], GlobalConfiguration],
 ) -> None:
     """Tests strict validation on 'smda.coordinate_system'."""
-    cfg = generate_strict_valid_globalconfiguration(  # type: ignore
-        coordinate_system=fields.CoordinateSystem(identifier="", uuid=uuid),
+    cfg = generate_strict_valid_globalconfiguration(
+        coordinate_system=fields.CoordinateSystem(identifier="", uuid=uuid),  # type: ignore
     )
     if valid:
         validate_global_configuration_strictly(cfg)  # Does not raise
@@ -230,8 +230,8 @@ def test_validate_global_config_strict_stratigraphic_column_uuids(
     generate_strict_valid_globalconfiguration: Callable[[], GlobalConfiguration],
 ) -> None:
     """Tests strict validation on 'smda.stratigraphic_column' uuid."""
-    cfg = generate_strict_valid_globalconfiguration(  # type: ignore
-        stratigraphic_column=fields.StratigraphicColumn(identifier="", uuid=uuid),
+    cfg = generate_strict_valid_globalconfiguration(
+        stratigraphic_column=fields.StratigraphicColumn(identifier="", uuid=uuid),  # type: ignore
     )
     if valid:
         validate_global_configuration_strictly(cfg)  # Does not raise
@@ -250,8 +250,8 @@ def test_validate_global_config_strict_stratigraphic_column_names(
     generate_strict_valid_globalconfiguration: Callable[[], GlobalConfiguration],
 ) -> None:
     """Tests strict validation on 'smda.stratigraphic_column' identifiers."""
-    cfg = generate_strict_valid_globalconfiguration(  # type: ignore
-        stratigraphic_column=fields.StratigraphicColumn(
+    cfg = generate_strict_valid_globalconfiguration(
+        stratigraphic_column=fields.StratigraphicColumn(  # type: ignore
             identifier=identifier, uuid=uuid4()
         ),
     )

fmu_settings-0.5.4/tests/test_resources/test_cache_manager.py

@@ -0,0 +1,116 @@
+"""Tests for the cache manager utilities."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from fmu.settings._resources.cache_manager import _CACHEDIR_TAG_CONTENT, CacheManager
+
+if TYPE_CHECKING:
+    import pytest
+
+    from fmu.settings._fmu_dir import ProjectFMUDirectory
+
+
+def _read_snapshot_names(config_cache: Path) -> list[str]:
+    return sorted(p.name for p in config_cache.iterdir() if p.is_file())
+
+
+def test_cache_manager_list_revisions_without_directory(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Listing revisions on a missing cache dir yields an empty list."""
+    manager = CacheManager(fmu_dir)
+    assert manager.list_revisions("foo.json") == []
+
+
+def test_cache_manager_list_revisions_with_existing_snapshots(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Listing revisions returns sorted snapshot paths."""
+    manager = CacheManager(fmu_dir)
+    manager.store_revision("foo.json", "one")
+    manager.store_revision("foo.json", "two")
+    revisions = manager.list_revisions("foo.json")
+    assert [path.name for path in revisions] == sorted(path.name for path in revisions)
+    assert len(revisions) == 2  # noqa: PLR2004
+
+
+def test_cache_manager_honours_existing_cachedir_tag(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Existing cachedir tags are preserved when storing revisions."""
+    cache_root = fmu_dir.path / "cache"
+    cache_root.mkdir(exist_ok=True)
+    tag_path = cache_root / "CACHEDIR.TAG"
+    tag_path.write_text("custom tag", encoding="utf-8")
+
+    manager = CacheManager(fmu_dir)
+    manager.store_revision("foo.json", '{"foo": "bar"}')
+
+    assert tag_path.read_text(encoding="utf-8") == "custom tag"
+
+
+def test_cache_manager_cache_root_helpers_create_tag(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Cache root helpers return consistent paths and create cachedir tags."""
+    manager = CacheManager(fmu_dir)
+    root = manager._cache_root_path(create=False)
+    assert root == fmu_dir.get_file_path("cache")
+
+    created = manager._cache_root_path(create=True)
+    assert created == root
+
+    tag_path = created / "CACHEDIR.TAG"
+    assert tag_path.is_file()
+    assert tag_path.read_text(encoding="utf-8") == _CACHEDIR_TAG_CONTENT
+
+
+def test_cache_manager_uses_default_extension_for_suffixless_paths(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Files without suffix get '.txt' snapshots."""
+    manager = CacheManager(fmu_dir)
+    snapshot = manager.store_revision("logs/entry", "payload")
+    assert snapshot is not None
+    assert snapshot.suffix == ".txt"
+    assert snapshot.read_text(encoding="utf-8") == "payload"
+
+
+def test_cache_manager_trim_handles_missing_files(
+    fmu_dir: ProjectFMUDirectory,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Trimming gracefully handles concurrent removals."""
+    manager = CacheManager(fmu_dir, max_revisions=1)
+    manager.store_revision("foo.json", "first")
+
+    original_unlink = Path.unlink
+
+    def flaky_unlink(self: Path, *, missing_ok: bool = False) -> None:
+        if self.name.endswith(".json") and not getattr(flaky_unlink, "raised", False):
+            flaky_unlink.raised = True  # type: ignore[attr-defined]
+            original_unlink(self, missing_ok=missing_ok)
+            raise FileNotFoundError
+        original_unlink(self, missing_ok=missing_ok)
+
+    monkeypatch.setattr(Path, "unlink", flaky_unlink)
+
+    manager.store_revision("foo.json", "second")
+
+    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()

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

@@ -19,6 +19,7 @@ from fmu.settings._resources.lock_manager import (
     DEFAULT_LOCK_TIMEOUT,
     LockError,
     LockManager,
+    LockNotFoundError,
 )
 from fmu.settings.models.lock_info import LockInfo
 
@@ -287,7 +288,7 @@ def test_is_stale_load_fails(fmu_dir: ProjectFMUDirectory) -> None:
     """Tests is_stale if loading the lock file fails."""
     lock = LockManager(fmu_dir)
     lock.acquire()
-    with patch.object(lock, "_safe_load", return_value=None):
+    with patch.object(lock, "safe_load", return_value=None):
         assert lock._is_stale() is True
 
 
@@ -414,6 +415,18 @@ def test_is_locked_by_other_process(
     assert lock.is_locked() is False
 
 
+def test_is_locked_propagate_errors(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests that load with propagate errors raises."""
+    lock = LockManager(fmu_dir)
+    lock.path.write_text("a")
+    assert lock.is_locked() is False
+
+    with pytest.raises(ValueError, match="Invalid JSON"):
+        assert lock.is_locked(propagate_errors=True) is False
+
+
 def test_is_acquired_expected(
     fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
 ) -> None:
@@ -493,15 +506,21 @@ def test_refresh_works_as_expected(
 def test_refresh_without_lock_file(
     fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
 ) -> None:
-    """Tests refresh when lock file is not present."""
-    lock = LockManager(fmu_dir)
-    with pytest.raises(LockError, match="does not exist"):
-        lock.refresh()
+    """Tests that if a user deletes anothers lock it's invalidated on a refresh."""
+    with pytest.raises(LockNotFoundError, match="does not exist"):
+        fmu_dir._lock.refresh()
 
-    lock.acquire()
-    lock.path.unlink()  # It was deleted or something.
-    with pytest.raises(LockError, match="does not exist"):
-        lock.refresh()
+    fmu_dir._lock.acquire()
+    assert fmu_dir._lock.is_acquired() is True
+
+    # Someone deletes the lock
+    fmu_dir._lock.path.unlink()
+
+    with pytest.raises(
+        LockNotFoundError, match="Cannot refresh: lock file does not exist"
+    ):
+        fmu_dir._lock.refresh()
+    assert fmu_dir._lock.is_acquired() is False
 
 
 def test_refresh_without_owning_lock(
@@ -533,11 +552,11 @@ def test_safe_load(fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch) -> No
     lock = LockManager(fmu_dir)
     lock.acquire()
     assert lock._cache is not None
-    assert lock._safe_load() == lock._cache
+    assert lock.safe_load() == lock._cache
 
     lock.release()
     lock.path.write_text("a")
-    assert lock._safe_load() is None
+    assert lock.safe_load() is None
 
 
 def test_save_expected(fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch) -> None:
@@ -597,7 +616,7 @@ def test_ensure_can_write_invalid_lock(fmu_dir: ProjectFMUDirectory) -> None:
     """Tests ensure_can_write ignores unreadable lock info."""
     lock = LockManager(fmu_dir)
     lock.path.write_text("garbage")
-    with patch.object(lock, "_safe_load", return_value=None):
+    with patch.object(lock, "safe_load", return_value=None):
         lock.ensure_can_write()
 
 
@@ -622,7 +641,7 @@ def test_ensure_can_write_stale_lock(fmu_dir: ProjectFMUDirectory) -> None:
     )
     lock.path.write_text(lock_info.model_dump_json(indent=2))
     with (
-        patch.object(lock, "_safe_load", return_value=lock_info),
+        patch.object(lock, "safe_load", return_value=lock_info),
         patch.object(lock, "is_acquired", return_value=False),
         patch.object(lock, "_is_stale", return_value=True),
     ):
@@ -649,18 +668,3 @@ def test_ensure_can_write_foreign_lock(fmu_dir: ProjectFMUDirectory) -> None:
         pytest.raises(PermissionError, match="Cannot write to .fmu directory"),
     ):
         lock.ensure_can_write()
-
-
-def test_manual_delete_invalidates_lock_file_on_refresh(
-    fmu_dir: ProjectFMUDirectory,
-) -> None:
-    """Tests that if a user deletes anothers lock it's invalidated on a refresh."""
-    fmu_dir._lock.acquire()
-    assert fmu_dir._lock.is_acquired() is True
-
-    # Someone deletes the lock
-    fmu_dir._lock.path.unlink()
-
-    with pytest.raises(LockError, match="Cannot refresh: lock file does not exist"):
-        fmu_dir._lock.refresh()
-    assert fmu_dir._lock.is_acquired() is False

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

@@ -1,6 +1,7 @@
 """Tests for fmu.settings.resources.managers."""
 
 import json
+import shutil
 from pathlib import Path
 from typing import Self
 from unittest.mock import patch
@@ -9,6 +10,7 @@ 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
 
@@ -184,3 +186,101 @@ def test_pydantic_resource_manager_loads_invalid_model(
         ValueError, match=r"Invalid content in resource file[\s\S]*input_value=0"
     ):
         a.load(force=True)
+
+
+def test_pydantic_resource_manager_save_does_not_cache_when_disabled(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Saving without cache enabled should not create cache artifacts."""
+    original_default = AManager.cache_enabled
+    AManager.cache_enabled = False
+    cache_root = fmu_dir.path / "cache"
+    try:
+        if cache_root.exists():
+            shutil.rmtree(cache_root)
+        a = AManager(fmu_dir)
+        a.save(A(foo="bar"))
+    finally:
+        AManager.cache_enabled = original_default
+
+    assert not cache_root.exists()
+
+
+def test_pydantic_resource_manager_save_stores_revision_when_enabled(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Saving with cache enabled should persist a revision snapshot."""
+    a = AManager(fmu_dir)
+    model = A(foo="bar")
+    a.save(model)
+
+    cache_root = fmu_dir.path / "cache"
+    assert cache_root.is_dir()
+    tag_path = cache_root / "CACHEDIR.TAG"
+    assert tag_path.read_text(encoding="utf-8").startswith(
+        "Signature: 8a477f597d28d172789f06886806bc55"
+    )
+
+    config_cache = cache_root / "foo"
+    snapshots = list(config_cache.iterdir())
+    assert len(snapshots) == 1
+    snapshot = snapshots[0]
+    assert snapshot.suffix == ".json"
+    assert json.loads(snapshot.read_text(encoding="utf-8")) == model.model_dump()
+
+
+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."""
+    original_limit = fmu_dir.cache_max_revisions
+    fmu_dir.cache_max_revisions = 3
+    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"))
+    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
+
+    contents = [
+        json.loads((config_cache / name).read_text(encoding="utf-8"))["foo"]
+        for name in snapshots
+    ]
+    assert contents == ["two", "three", "four"]