Merge pull request #609 from uttam12331/fix/slots-mangled-subclass-506

Fix mangled __slots__ attribute lost for subclass instances (#506)

Author: seperman

CHANGELOG.md

@@ -4,6 +4,7 @@
     - Fixed missing type changes between equal-comparing items inside ordered iterables, e.g. `DeepDiff([2], [2.0])` now reports the `int` → `float` change like `DeepDiff(2, 2.0)` and `DeepDiff({'a': 2}, {'a': 2.0})` already do (issue #605).
 
 - v9-1-0
+    - Fixed `_dict_from_slots` dropping a parent-declared mangled `__slots__` attribute for a subclass instance, because the name was unmangled using the concrete instance type instead of the declaring class (#506)
     - Added multiprocessing support for DeepDiff: parallel distance computation and parallel subtree diffing with aggregated worker stats, deterministic ordering, and automatic fallback to serial when unsafe (e.g. `custom_operators`, `*_obj_callback`, `ignore_order_func`)
     - Added wildcard/glob pattern support for `exclude_paths` and `include_paths` thanks to [akshat62](https://github.com/akshat62)
     - Reimplemented internal cache for improved performance

deepdiff/diff.py

@@ -503,10 +503,13 @@ def _skip_report_for_include_glob(self, level):
 
     @staticmethod
     def _dict_from_slots(object: Any) -> Dict[str, Any]:
-        def unmangle(attribute: str) -> str:
+        def unmangle(attribute: str, klass: type) -> str:
+            # A mangled slot (e.g. ``__id``) is stored under the name of the
+            # class that declared it, not the concrete instance type, so a
+            # subclass instance would otherwise lose a parent-defined slot (#506).
             if attribute.startswith('__') and attribute != '__weakref__':
                 return '_{type}{attribute}'.format(
-                    type=type(object).__name__,
+                    type=klass.__name__,
                     attribute=attribute
                 )
             return attribute
@@ -522,11 +525,15 @@ def unmangle(attribute: str) -> str:
             slots = getattr(type_in_mro, '__slots__', None)
             if slots:
                 if isinstance(slots, strings):
-                    all_slots.append(slots)
+                    all_slots.append((type_in_mro, slots))
                 else:
-                    all_slots.extend(slots)
+                    all_slots.extend((type_in_mro, i) for i in slots)
 
-        return {i: getattr(object, key) for i in all_slots if hasattr(object, key := unmangle(i))}
+        return {
+            i: getattr(object, key)
+            for (klass, i) in all_slots
+            if hasattr(object, key := unmangle(i, klass))
+        }
 
     def _diff_enum(self, level: Any, parents_ids: FrozenSet[int]=frozenset(), local_tree: Optional[Any]=None) -> None:
         t1 = detailed__dict__(level.t1, include_keys=ENUM_INCLUDE_KEYS)

tests/test_diff_text.py

@@ -868,6 +868,22 @@ class ClassB(ClassA):
         result = {}
         assert result == ddiff
 
+    def test_dict_from_slots_of_subclass_with_mangled_attribute(self):
+        # A mangled slot (e.g. ``__id``) declared on a parent class is stored
+        # under the parent's mangled name, so it must be unmangled using the
+        # declaring class, not the concrete instance type. Otherwise a subclass
+        # instance silently loses the parent-defined slot. See #506.
+        class ClassA:
+            __slots__ = ('__id',)
+
+            def __init__(self, id):
+                self.__id = id
+
+        class ClassB(ClassA):
+            pass
+
+        assert DeepDiff._dict_from_slots(ClassA(5)) == {'__id': 5}
+        assert DeepDiff._dict_from_slots(ClassB(5)) == {'__id': 5}
 
     def test_custom_class_changes_none_when_ignore_type(self):
         ddiff1 = DeepDiff({'a': None}, {'a': 1}, ignore_type_subclasses=True, ignore_type_in_groups=[(int, float)])