Compare_entities diff uses id instead of name where needed

Summary

Addresses https://gitlab.indiscale.com/caosdb/customers/f-fit/management/-/issues/94 / https://gitlab.com/linkahead/linkahead-pylib/-/issues/119
When comparing two properties or parents where at least one of these properties/parents do not have a name, only an id, compare_entities now uses the id as a key for the diff.
Test-MR: caosdb-pyinttest!84 (merged)

Focus

• Is this compatible with the crawler?
• Would it be better to instead use the id as primary key and name as fallback?

Test Environment

Manual Testing

Check List for the Author

• All automated tests pass
• Reference related issues
• Up-to-date CHANGELOG.md (or not necessary)
• Up-to-date JSON schema (or not necessary)
• Appropriate user and developer documentation (or not necessary)
• Annotations in code (Gitlab comments)

Check List for the Reviewer

• I understand the intent of this MR
• All automated tests pass
• Up-to-date CHANGELOG.md (or not necessary)
• Appropriate user and developer documentation (or not necessary)
• The test environment setup works and the intended behavior is reproducible in the test environment
• In-code documentation and comments are up-to-date.
• Check: Are there specifications? Are they satisfied?

src/linkahead/apiutils.py

@@ -196,6 +196,8 @@ def compare_entities(entity0: Optional[Entity] = None,
     that are missing in the other entity, and the 'properties' dict contains
     properties and SPECIAL_ATTRIBUTES if they are missing or different from
     their counterparts in the other entity.
+    The key used to represent a parent or property is the entities name if the
+    name is present for both compared entities, the id otherwise.
 
     The value of the properties dict for each listed property is again a dict
     detailing the differences between this property and its counterpart.
@@ -224,9 +226,9 @@ def compare_entities(entity0: Optional[Entity] = None,
 
     Params
     ------
-    entity0                : Entity
+    entity0:                    Entity
                                 First entity to be compared.
-    entity1                : Entity
+    entity1:                    Entity
                                 Second entity to be compared.
     compare_referenced_records: bool, default: False
                                 If set to True, values with referenced records
@@ -377,15 +379,20 @@ def compare_entities(entity0: Optional[Entity] = None,
 
     # compare properties
     for prop in entity0.properties:
-        matching = entity1.properties.filter(name=prop.name, pid=prop.id)
+        # ToDo: Would making id default break anything?
+        key = prop.name if prop.name is not None else prop.id
+        matching = entity1.properties.filter(prop)
         if len(matching) == 0:
             # entity1 has prop, entity0 does not
-            diff[0]["properties"][prop.name] = {}
+            diff[0]["properties"][key] = {}
         elif len(matching) == 1:
-            diff[0]["properties"][prop.name] = {}
-            diff[1]["properties"][prop.name] = {}
-            propdiff = (diff[0]["properties"][prop.name],
-                        diff[1]["properties"][prop.name])
+            # It's possible that prop has name and id, but match only has id
+            key = prop.name if (prop.name is not None and
+                                matching[0].name == prop.name) else prop.id
+            diff[0]["properties"][key] = {}
+            diff[1]["properties"][key] = {}
+            propdiff = (diff[0]["properties"][key],
+                        diff[1]["properties"][key])
 
             # We should compare the wrapped properties instead of the
             # wrapping entities if possible:
@@ -417,8 +424,8 @@ def compare_entities(entity0: Optional[Entity] = None,
 
             # in case there is no difference, we remove the dict keys again
             if len(propdiff[0]) == 0 and len(propdiff[1]) == 0:
-                diff[0]["properties"].pop(prop.name)
-                diff[1]["properties"].pop(prop.name)
+                diff[0]["properties"].pop(key)
+                diff[1]["properties"].pop(key)
 
         else:
             raise NotImplementedError(
@@ -426,11 +433,12 @@ def compare_entities(entity0: Optional[Entity] = None,
 
     # we have not yet compared properties that do not exist in entity0
     for prop in entity1.properties:
+        key = prop.name if prop.name is not None else prop.id
         # check how often the property appears in entity0
         num_prop_in_ent0 = len(entity0.properties.filter(prop))
         if num_prop_in_ent0 == 0:
             # property is only present in entity0 - add to diff
-            diff[1]["properties"][prop.name] = {}
+            diff[1]["properties"][key] = {}
         if num_prop_in_ent0 > 1:
             # Check whether the property is present multiple times in entity0
             # and raise error - result would be incorrect
@@ -441,9 +449,10 @@ def compare_entities(entity0: Optional[Entity] = None,
     for index, parents, other_entity in [(0, entity0.parents, entity1),
                                          (1, entity1.parents, entity0)]:
         for parent in parents:
+            key = parent.name if parent.name is not None else parent.id
             matching = other_entity.parents.filter(parent)
             if len(matching) == 0:
-                diff[index]["parents"].append(parent.name)
+                diff[index]["parents"].append(key)
                 continue
 
     return diff