fmu-settings 0.3.0__tar.gz → 0.3.2__tar.gz

{fmu_settings-0.3.0 → fmu_settings-0.3.2}/PKG-INFO

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

{fmu_settings-0.3.0 → fmu_settings-0.3.2}/src/fmu/settings/_resources/lock_manager.py

@@ -153,7 +153,17 @@ class LockManager(PydanticResourceManager[LockInfo]):
                 temp_path.unlink()
 
     def is_locked(self: Self) -> bool:
-        """Returns whether or not the lock is currently locked."""
+        """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)
+        if not lock_info:
+            return False
+        return time.time() < lock_info.expires_at
+
+    def is_acquired(self: Self) -> bool:
+        """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()
@@ -219,13 +229,13 @@ class LockManager(PydanticResourceManager[LockInfo]):
             and lock_info.acquired_at == self._acquired_at
         )
 
-    def _safe_load(self: Self) -> LockInfo | None:
+    def _safe_load(self: Self, force: 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()
+            return self.load(force=force)
         except Exception:
             return None
 

{fmu_settings-0.3.0 → fmu_settings-0.3.2}/src/fmu/settings/_resources/pydantic_resource_manager.py

@@ -48,11 +48,14 @@ class PydanticResourceManager(Generic[T]):
         """Returns whether or not the resource exists."""
         return self.path.exists()
 
-    def load(self: Self, force: bool = False) -> T:
-        """Loads the resources from disk and validates it as a Pydantic model.
+    def load(self: Self, force: bool = False, store_cache: bool = True) -> T:
+        """Loads the resource from disk and validates it as a Pydantic model.
 
         Args:
-            force: Force a re-read even if the file is already cached
+            force: Force a re-read even if the file is already cached.
+            store_cache: Whether or not to cache the loaded model internally. This is
+                best used with 'force=True' because if a model is already stored in
+                _cache it will be returned without re-loading. Default True.
 
         Returns:
             Validated Pydantic model
@@ -71,7 +74,11 @@ class PydanticResourceManager(Generic[T]):
             try:
                 content = self.fmu_dir.read_text_file(self.relative_path)
                 data = json.loads(content)
-                self._cache = self.model_class.model_validate(data)
+                validated_model = self.model_class.model_validate(data)
+                if store_cache:
+                    self._cache = validated_model
+                else:
+                    return validated_model
             except ValidationError as e:
                 raise ValueError(
                     f"Invalid content in resource file for '{self.__class__.__name__}: "

{fmu_settings-0.3.0 → fmu_settings-0.3.2}/src/fmu/settings/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.0'
-__version_tuple__ = version_tuple = (0, 3, 0)
+__version__ = version = '0.3.2'
+__version_tuple__ = version_tuple = (0, 3, 2)
 
-__commit_id__ = commit_id = 'g5fa25d14f'
+__commit_id__ = commit_id = 'g9ea88b68f'

{fmu_settings-0.3.0 → fmu_settings-0.3.2}/src/fmu_settings.egg-info/PKG-INFO

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

{fmu_settings-0.3.0 → fmu_settings-0.3.2}/tests/test_fmu_dir.py

@@ -333,7 +333,7 @@ def test_acquire_lock_on_project_fmu(
 ) -> None:
     """Tests that a lock can be acquired on the project dir."""
     fmu_dir._lock.acquire()
-    assert fmu_dir._lock.is_locked()
+    assert fmu_dir._lock.is_acquired()
     assert fmu_dir._lock.exists
     assert (fmu_dir.path / ".lock").exists()
 
@@ -343,6 +343,6 @@ def test_acquire_lock_on_user_fmu(
 ) -> None:
     """Tests that a lock can be acquired on the user dir."""
     user_fmu_dir._lock.acquire()
-    assert user_fmu_dir._lock.is_locked()
+    assert user_fmu_dir._lock.is_acquired()
     assert user_fmu_dir._lock.exists
     assert (user_fmu_dir.path / ".lock").exists()

{fmu_settings-0.3.0 → fmu_settings-0.3.2}/tests/test_resources/test_lock_manager.py

@@ -95,6 +95,7 @@ def test_lock_acquire_raises_if_already_acquired(fmu_dir: ProjectFMUDirectory) -
     lock = LockManager(fmu_dir)
     lock.acquire()
     assert lock.is_locked()
+    assert lock.is_acquired()
     with pytest.raises(LockError, match="Lock already acquired"):
         lock.acquire()
 
@@ -190,6 +191,7 @@ def test_lock_acquire_over_expired_lock(fmu_dir: ProjectFMUDirectory) -> None:
     stale_lock = LockManager(fmu_dir, timeout_seconds=-1)  # Expired
     stale_lock.acquire()
     assert stale_lock.is_locked() is False
+    assert stale_lock.is_acquired() is False
     assert stale_lock._is_stale() is True
     stale_lock_info = stale_lock.load()
 
@@ -198,6 +200,7 @@ def test_lock_acquire_over_expired_lock(fmu_dir: ProjectFMUDirectory) -> None:
     lock_info = lock.load()
 
     assert lock.is_locked()
+    assert lock.is_acquired()
     assert stale_lock.path == lock.path
     assert lock_info != stale_lock_info
 
@@ -385,27 +388,55 @@ def test_try_acquire_fails_when_linking_temp_file(
 def test_is_locked_expected(
     fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
 ) -> None:
-    """Tests is_locked under expected conditions."""
+    """Tests is_locked under expected, simple conditions."""
     lock = LockManager(fmu_dir)
     assert lock.is_locked() is False
     lock.acquire()
     assert lock.is_locked() is True
+    lock.release()
+    assert lock.is_locked() is False
 
 
-def test_is_locked_unexpected_members(
+def test_is_locked_by_other_process(
     fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
 ) -> None:
-    """Tests is_locked under expected member conditions."""
+    """Tests is_locked when another process has the lock."""
     lock = LockManager(fmu_dir)
     assert lock.is_locked() is False
-    lock.acquire()
+    with patch("os.getpid", return_value=-1234):
+        lock.acquire()
+
     assert lock.is_locked() is True
+
+    with patch("os.getpid", return_value=-1234):
+        lock.release()
+    assert lock.is_locked() is False
+
+
+def test_is_acquired_expected(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests is_acquired under expected conditions."""
+    lock = LockManager(fmu_dir)
+    assert lock.is_acquired() is False
+    lock.acquire()
+    assert lock.is_acquired() is True
+
+
+def test_is_acquired_unexpected_members(
+    fmu_dir: ProjectFMUDirectory, monkeypatch: MonkeyPatch
+) -> None:
+    """Tests is_acquired under expected member conditions."""
+    lock = LockManager(fmu_dir)
+    assert lock.is_acquired() is False
+    lock.acquire()
+    assert lock.is_acquired() is True
     lock_info = lock._cache
     lock._cache = None
-    assert lock.is_locked() is False
+    assert lock.is_acquired() is False
     lock._cache = lock_info
     lock._acquired_at = None
-    assert lock.is_locked() is False
+    assert lock.is_acquired() is False
 
 
 @pytest.mark.parametrize(
@@ -417,23 +448,23 @@ def test_is_locked_unexpected_members(
         (False, False, False),
     ],
 )
-def test_is_locked_unexpected_methods(
+def test_is_acquired_unexpected_methods(
     fmu_dir: ProjectFMUDirectory,
     monkeypatch: MonkeyPatch,
     is_mine: bool,
     is_stale: bool,
     expected: bool,
 ) -> None:
-    """Tests is_locked under expected method conditions."""
+    """Tests is_acquired under expected method conditions."""
     lock = LockManager(fmu_dir)
-    assert lock.is_locked() is False
+    assert lock.is_acquired() is False
     lock.acquire()
 
     with (
         patch.object(lock, "_is_mine", return_value=is_mine),
         patch.object(lock, "_is_stale", return_value=is_stale),
     ):
-        assert lock.is_locked() is expected
+        assert lock.is_acquired() is expected
 
 
 def test_refresh_works_as_expected(

{fmu_settings-0.3.0 → fmu_settings-0.3.2}/tests/test_resources/test_resource_managers.py

@@ -87,6 +87,62 @@ def test_pydantic_resource_manager_load(fmu_dir: ProjectFMUDirectory) -> None:
     assert a._cache == a_model
 
 
+def test_pydantic_resource_manager_load_force_true(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Tests loading a Pydantic resource with force=True."""
+    a = AManager(fmu_dir)
+    a_model = A(foo="bar")
+    a.save(a_model)
+    assert a.load() == a_model
+    assert a._cache == a_model
+
+    a_shadow = AManager(fmu_dir)
+    a_shadow_model = A(foo="baz")
+    a_shadow.save(a_shadow_model)
+
+    assert a_shadow.load() == a_shadow_model
+    assert a_shadow._cache == a_shadow_model
+
+    assert a.load() == a_model
+    assert a._cache == a_model
+
+    assert a.load(force=True) == a_shadow_model
+    assert a._cache == a_shadow_model
+
+
+def test_pydantic_resource_manager_load_cache_false(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Tests loading a Pydantic resource with cache=False."""
+    a = AManager(fmu_dir)
+    a_model = A(foo="bar")
+    a.save(a_model)
+
+    a_shadow = AManager(fmu_dir)
+    assert a_shadow.load(store_cache=False) == a_model
+    assert a_shadow._cache is None
+
+    assert a_shadow.load(store_cache=True) == a_model
+    assert a_shadow._cache == a_model
+
+
+def test_pydantic_resource_manager_load_force_true_cache_false(
+    fmu_dir: ProjectFMUDirectory,
+) -> None:
+    """Tests loading a Pydantic resource with force=True, cache=False."""
+    a = AManager(fmu_dir)
+    a_model = A(foo="bar")
+    a.save(a_model)
+
+    a_shadow = AManager(fmu_dir)
+    a_shadow_model = A(foo="baz")
+    a_shadow.save(a_shadow_model)
+
+    assert a.load(force=True, store_cache=False) == a_shadow_model
+    assert a._cache is a_model
+
+
 def test_pydantic_resource_manager_loads_invalid_model(
     fmu_dir: ProjectFMUDirectory,
 ) -> None: