I. Nüske
--- a/src/linkahead/common/models.py
+++ b/src/linkahead/common/models.py
    IMPORTANCE = Literal["OBLIGATORY", "RECOMMENDED", "SUGGESTED", "FIX", "NONE"]
    ROLE = Literal["Entity", "Record", "RecordType", "Property", "File"]

-SPECIAL_ATTRIBUTES = ["name", "role", "datatype", "description",
-                      "id", "path", "checksum", "size", "value"]
+SPECIAL_ATTRIBUTES = ["name", "role", "datatype", "description", "file",
+                      "id", "path", "checksum", "size", "value", "unit"]
--- a/src/linkahead/apiutils.py
+++ b/src/linkahead/apiutils.py
-    if type(old_entity) is not type(new_entity):
+    # ToDo: Discuss intended behaviour
+    # Questions that need clarification:
+    #    - What is intended behaviour for multi-properties and multi-parents?
+    #    - Do different inheritance levels for parents count as a difference?
+    #    - Do we care about parents and properties of properties?
+    #    - Should there be a more detailed comparison of parents without id?
+    #    - Revisit filter - do we care about RecordType when matching?
+    #      How to treat None?
+    # Suggestions for enhancements:
+    #    - For the comparison of entities in value and properties, consider
+    #      keeping a list of traversed entities, not only look at first layer
+    #    - Make the empty_diff functionality faster by adding a parameter to
+    #      this function so that it returns after the first found difference?
+    #    - Add parameter to restrict diff to some characteristics
+    entity0, entity1 = old_entity, new_entity
--- a/src/linkahead/apiutils.py
+++ b/src/linkahead/apiutils.py
+            # We do not care about parents and properties here, discard
+            od.pop("parents")
+            od.pop("properties")
+            nd.pop("parents")
+            nd.pop("properties")
+            # use the remaining diff
+            propdiff[0].update(od)
+            propdiff[1].update(nd)
+
+            # As the importance of a property is an attribute of the record
+            # and not the property, it is not contained in the diff returned
+            # by compare_entities and needs to be added separately
+            if (entity0.get_importance(prop) !=
+                    entity1.get_importance(matching[0])):
+                propdiff[0]["importance"] = entity0.get_importance(prop)
+                propdiff[1]["importance"] = entity1.get_importance(matching[0])
--- a/unittests/test_apiutils.py
+++ b/unittests/test_apiutils.py
    assert diff_r2["properties"]["test"]["unit"] == "m"


+def test_compare_entities_battery():
+    par1, par2, par3 = db.Record(), db.Record(), db.RecordType()
+    r1, r2, r3 = db.Record(), db.Record(), db.Record()
+    prop1 = db.Property()
+    prop2 = db.Property(name="Property 2")
+    prop3 = db.Property()
--- a/src/linkahead/common/models.py
+++ b/src/linkahead/common/models.py
+    potentials = list(zip(listobject.copy(), [False]*len(listobject)))
+    for candidate, wrapped_is_checked in potentials:
+        name_match, pid_match, original_candidate = False, False, None
+
+        # Parents/Properties may be wrapped - if wanted, try to match original
+        # Note: if we want to check all wrapped Entities, this should be
+        #       switched. First check the wrap, then append wrapped. In this
+        #       case we also don't need wrapped_checked, but preferentially
+        #       append the wrapper.
+        if check_wrapped and not wrapped_is_checked:
+            try:
+                if candidate._wrapped_entity is not None:
+                    original_candidate = candidate
+                    candidate = candidate._wrapped_entity
+            except:
+                pass