fmu-settings 0.5.3__tar.gz → 0.6.0__tar.gz

{fmu_settings-0.5.3 → fmu_settings-0.6.0}/PKG-INFO

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

{fmu_settings-0.5.3 → fmu_settings-0.6.0}/src/fmu/settings/_fmu_dir.py

@@ -1,14 +1,16 @@
 """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 ._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
 
@@ -22,13 +24,23 @@ class FMUDirectoryBase:
 
     config: FMUConfigManager
     _lock: LockManager
-
-    def __init__(self: Self, base_path: str | Path) -> None:
+    _cache_manager: CacheManager
+    _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
@@ -37,7 +49,8 @@ class FMUDirectoryBase:
         """
         self.base_path = Path(base_path).resolve()
         logger.debug(f"Initializing FMUDirectory from '{base_path}'")
-        self._lock = LockManager(self)
+        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():
@@ -57,6 +70,28 @@ 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.
+
+        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.
 
@@ -212,14 +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):
-    config: ProjectConfigManager
+    if TYPE_CHECKING:
+        config: ProjectConfigManager
+
+    _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.
 
-    def __init__(self, base_path: str | Path) -> 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.
@@ -287,12 +367,34 @@ class ProjectFMUDirectory(FMUDirectoryBase):
 
 
 class UserFMUDirectory(FMUDirectoryBase):
-    config: UserConfigManager
+    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.

{fmu_settings-0.5.3 → fmu_settings-0.6.0}/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.0/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.6.0/src/fmu/settings/_resources/cache_manager.py

@@ -0,0 +1,153 @@
+"""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, ClassVar, 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."""
+
+    MIN_REVISIONS: ClassVar[int] = 5
+
+    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.
+                Values below 5 are set to 5.
+        """
+        self._fmu_dir = fmu_dir
+        self._cache_root = Path("cache")
+        self._max_revisions = max(self.MIN_REVISIONS, 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.
+
+        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,
+        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.
+        """
+        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.3 → fmu_settings-0.6.0}/src/fmu/settings/_resources/lock_manager.py

@@ -39,6 +39,8 @@ class LockNotFoundError(FileNotFoundError):
 class LockManager(PydanticResourceManager[LockInfo]):
     """Manages the .lock file."""
 
+    cache_enabled: bool = False
+
     def __init__(
         self: Self,
         fmu_dir: FMUDirectoryBase,
@@ -86,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} "
@@ -156,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
@@ -170,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
@@ -202,7 +209,7 @@ class LockManager(PydanticResourceManager[LockInfo]):
                 self.release()
             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."
@@ -214,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()
@@ -222,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."
@@ -254,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.3 → fmu_settings-0.6.0}/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.3 → fmu_settings-0.6.0}/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.3'
-__version_tuple__ = version_tuple = (0, 5, 3)
+__version__ = version = '0.6.0'
+__version_tuple__ = version_tuple = (0, 6, 0)
 
-__commit_id__ = commit_id = 'g7953e1c0f'
+__commit_id__ = commit_id = 'g746436036'

{fmu_settings-0.5.3 → fmu_settings-0.6.0}/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,
         )