Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
23 changes: 19 additions & 4 deletions deepdiff/diff.py
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down
57 changes: 57 additions & 0 deletions tests/test_diff_text.py
Original file line number Diff line number Diff line change
Expand Up @@ -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",
Expand Down