sdk: Fix LocalFileIdentifiableStore mutation persistence

Previously, mutations to objects retrieved from
`LocalFileIdentifiableStore` were never written back to disk.
Only `add()` wrote to the file store; subsequent in-memory changes
were invisible to other processes (e.g. different uWSGI workers)
once the `WeakValueDictionary` cache was evicted.

This was an issue introduced in #370, which removed
`Referable.commit()` and the `LocalFileBackend` class without
replacing the write-back mechanism.

Two fixes are made here:

- `AbstractObjectStore.commit()` is added as a no-op default.
  `LocalFileIdentifiableStore` overrides it to re-serialize the
  object to its `.json` file.
- `get_item()` now returns the cached object directly on a cache
  hit, instead of always re-reading from disk and overwriting
  in-memory state. This was a secondary bug that would silently
  discard mutations within the same process if the same object
  was retrieved more than once.

A regression test (`test_mutation_persistence`) is added that
mutates a stored object, evicts the cache via `gc.collect()`,
and verifies the updated value is read back from disk.

Author: s-heppner

sdk/basyx/aas/backend/local_file.py

@@ -68,21 +68,14 @@ def get_identifiable_by_hash(self, hash_: str) -> model.Identifiable:
 
         :raises KeyError: If the respective file could not be found
         """
-        # Try to get the correct file
         try:
             with open("{}/{}.json".format(self.directory_path, hash_), "r") as file:
                 data = json.load(file, cls=json_deserialization.AASFromJsonDecoder)
                 obj = data["data"]
         except FileNotFoundError as e:
             raise KeyError("No Identifiable with hash {} found in local file database".format(hash_)) from e
-        # If we still have a local replication of that object (since it is referenced from anywhere else), update that
-        # replication and return it.
         with self._object_cache_lock:
-            if obj.id in self._object_cache:
-                old_obj = self._object_cache[obj.id]
-                old_obj.update_from(obj)
-                return old_obj
-        self._object_cache[obj.id] = obj
+            self._object_cache[obj.id] = obj
         return obj
 
     def get_item(self, identifier: model.Identifier) -> model.Identifiable:
@@ -91,6 +84,9 @@ def get_item(self, identifier: model.Identifier) -> model.Identifiable:
 
         :raises KeyError: If the respective file could not be found
         """
+        with self._object_cache_lock:
+            if identifier in self._object_cache:
+                return self._object_cache[identifier]
         try:
             return self.get_identifiable_by_hash(self._transform_id(identifier))
         except KeyError as e:
@@ -110,6 +106,18 @@ def add(self, x: model.Identifiable) -> None:
             with self._object_cache_lock:
                 self._object_cache[x.id] = x
 
+    def commit(self, x: model.Identifiable) -> None:
+        """
+        Write the current in-memory state of a stored object back to its file.
+
+        :param x: The object to persist
+        :raises KeyError: If the object is not present in the store
+        """
+        if not os.path.exists("{}/{}.json".format(self.directory_path, self._transform_id(x.id))):
+            raise KeyError("No AAS object with id {} exists in local file database".format(x.id))
+        with open("{}/{}.json".format(self.directory_path, self._transform_id(x.id)), "w") as file:
+            json.dump({"data": x}, file, cls=json_serialization.AASToJsonEncoder, indent=4)
+
     def discard(self, x: model.Identifiable) -> None:
         """
         Delete an :class:`~basyx.aas.model.base.Identifiable` AAS object from the local file store

sdk/basyx/aas/model/provider.py

@@ -59,6 +59,18 @@ class AbstractObjectStore(AbstractObjectProvider[_KEY, _VALUE], MutableSet[_VALU
     def __init__(self):
         pass
 
+    def commit(self, x: _VALUE) -> None:
+        """
+        Persist an in-memory mutation of a stored object back to the underlying storage.
+
+        The default implementation is a no-op, suitable for in-memory stores where the object
+        is the storage. Persistent backends (e.g. file-based or database-backed stores) must
+        override this to write the updated object back to storage.
+
+        :param x: The object whose current in-memory state should be persisted
+        """
+        pass
+
     def update(self, other: Iterable[_VALUE]) -> None:
         for x in other:
             self.add(x)

sdk/test/backend/test_local_file.py

@@ -4,6 +4,7 @@
 # the LICENSE file of this project.
 #
 # SPDX-License-Identifier: MIT
+import gc
 import os.path
 import shutil
 
@@ -134,6 +135,32 @@ def test_iter_ignores_non_json_files(self) -> None:
         self.assertEqual(5, len(items))
         os.remove(stray)
 
+    def test_mutation_persistence(self) -> None:
+        submodel = model.Submodel(
+            id_='https://example.org/MutationTest',
+            submodel_element={
+                model.Property(id_short='Prop', value_type=model.datatypes.String, value='before')
+            }
+        )
+        self.identifiable_store.add(submodel)
+
+        retrieved = self.identifiable_store.get_item('https://example.org/MutationTest')
+        assert isinstance(retrieved, model.Submodel)
+        prop = retrieved.get_referable(['Prop'])
+        assert isinstance(prop, model.Property)
+        prop.update_from(model.Property(id_short='Prop', value_type=model.datatypes.String, value='after'))
+        self.identifiable_store.commit(retrieved)
+
+        # Drop all strong references to evict the WeakValueDictionary cache
+        del submodel, retrieved, prop
+        gc.collect()
+
+        fresh = self.identifiable_store.get_item('https://example.org/MutationTest')
+        assert isinstance(fresh, model.Submodel)
+        fresh_prop = fresh.get_referable(['Prop'])
+        assert isinstance(fresh_prop, model.Property)
+        self.assertEqual('after', fresh_prop.value)
+
     def test_reload_discard(self) -> None:
         # Load example submodel
         example_submodel = create_example_submodel()