From e4aee3592b0e2c9b9e7ba5f3b658b6a247fd6f04 Mon Sep 17 00:00:00 2001 From: tony1233200 <127579663+tony1233200@users.noreply.github.com> Date: Fri, 20 Nov 2026 09:33:46 +0000 Subject: [PATCH] Fix DeepDiff on dict subclasses with non-standard iteration Dict subclasses may override __iter__ to yield values instead of keys (google.cloud.spanner JsonObject holding a JSON array does this), which made _diff_dict crash building its key sets on unhashable values. Collect keys via .keys() instead, which is identical for well-behaved dicts. Dict subclasses exposing no keys at all but unequal content (JsonObject holding a scalar) are now reported as changed instead of silently returning {}. Fixes #569 --- deepdiff/diff.py | 23 ++++++++++++++--- tests/test_diff_text.py | 57 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 76 insertions(+), 4 deletions(-) diff --git a/deepdiff/diff.py b/deepdiff/diff.py index c044383a..cf13c1d9 100755 --- a/deepdiff/diff.py +++ b/deepdiff/diff.py @@ -748,12 +748,27 @@ def _diff_dict( item_removed_key = "dictionary_item_removed" rel_class = DictRelationship + # Iterate .keys() rather than the dict itself: some dict subclasses + # (e.g. google.cloud.spanner JsonObject holding a JSON array) override + # __iter__ to yield values instead of keys, which made the key + # collection below crash on unhashable values. For well-behaved dicts + # iter(d) and iter(d.keys()) are identical. + # Dict subclasses can hold state that is not exposed as keys at all + # (e.g. a JsonObject holding a scalar value). When neither side + # exposes any raw key yet the objects are not equal, there is nothing + # to descend into, so report the whole value as changed instead of + # silently returning {}. Raw keys (before any private-key filtering) + # are used so ignored private keys alone never trigger this. + if not t1.keys() and not t2.keys() and t1 != t2: + self._report_result('values_changed', level, local_tree=local_tree) + return + if self.ignore_private_variables: - t1_keys = SetOrdered([key for key in t1 if not(isinstance(key, str) and key.startswith('__')) and not self._skip_this_key(level, key)]) - t2_keys = SetOrdered([key for key in t2 if not(isinstance(key, str) and key.startswith('__')) and not self._skip_this_key(level, key)]) + t1_keys = SetOrdered([key for key in t1.keys() if not(isinstance(key, str) and key.startswith('__')) and not self._skip_this_key(level, key)]) + t2_keys = SetOrdered([key for key in t2.keys() if not(isinstance(key, str) and key.startswith('__')) and not self._skip_this_key(level, key)]) else: - t1_keys = SetOrdered([key for key in t1 if not self._skip_this_key(level, key)]) - t2_keys = SetOrdered([key for key in t2 if not self._skip_this_key(level, key)]) + t1_keys = SetOrdered([key for key in t1.keys() if not self._skip_this_key(level, key)]) + t2_keys = SetOrdered([key for key in t2.keys() if not self._skip_this_key(level, key)]) if self.ignore_string_type_changes or self.ignore_numeric_type_changes or self.ignore_string_case: t1_clean_to_keys = self._get_clean_to_keys_mapping(keys=t1_keys, level=level) t2_clean_to_keys = self._get_clean_to_keys_mapping(keys=t2_keys, level=level) diff --git a/tests/test_diff_text.py b/tests/test_diff_text.py index cfeda768..c121d319 100755 --- a/tests/test_diff_text.py +++ b/tests/test_diff_text.py @@ -1573,6 +1573,63 @@ def test_skip_type(self): ddiff = DeepDiff(t1, t2, exclude_types={logging.Logger}) assert {} == ddiff + def test_dict_subclass_whose_iter_yields_values(self): + """A dict subclass whose __iter__ yields values instead of keys + (like google.cloud.spanner_v1.data_types.JsonObject holding a JSON + array) must still diff by keys. See #569.""" + + class ArrayDict(dict): + def __init__(self, values): + super().__init__() + self._values = list(values) + + def keys(self): + return dict(enumerate(self._values)).keys() + + def __getitem__(self, key): + return self._values[key] + + def __iter__(self): + return iter(self._values) + + def __len__(self): + return len(self._values) + + t1 = ArrayDict([]) + t2 = ArrayDict([{"size": "L", "color": "red"}]) + assert DeepDiff(t1, t2) == {'dictionary_item_added': ['root[0]']} + assert DeepDiff(t2, t1) == {'dictionary_item_removed': ['root[0]']} + assert DeepDiff(ArrayDict([1]), ArrayDict([2])) == { + 'values_changed': {'root[0]': {'new_value': 2, 'old_value': 1}}} + assert DeepDiff(ArrayDict([1]), ArrayDict([1])) == {} + nested = DeepDiff({"j": ArrayDict([])}, {"j": ArrayDict([1, 2])}) + assert set(nested['values_changed']) == {"root['j']"} + assert nested['values_changed']["root['j']"]['new_value']._values == [1, 2] + assert nested['values_changed']["root['j']"]['old_value']._values == [] + + def test_dict_subclass_with_no_keys_but_hidden_state(self): + """A dict subclass exposing no keys but unequal content (like a + JsonObject holding a scalar value) is reported as changed instead of + silently returning {}. See #569.""" + + class ScalarDict(dict): + def __init__(self, value): + super().__init__() + self._value = value + + def __eq__(self, other): + return isinstance(other, ScalarDict) and self._value == other._value + + def __ne__(self, other): + return not self.__eq__(other) + + diff = DeepDiff(ScalarDict(5), ScalarDict(6)) + assert set(diff['values_changed']) == {'root'} + assert diff['values_changed']['root']['new_value'] == ScalarDict(6) + assert diff['values_changed']['root']['old_value'] == ScalarDict(5) + assert DeepDiff(ScalarDict(5), ScalarDict(5)) == {} + assert DeepDiff({}, {}) == {} + def test_skip_path1(self): t1 = { "for life": "vegan",