r"""

def __init__(self,

t1,

t2,

ignore_order=False,

report_repetition=False,

significant_digits=None,

exclude_paths=set(),

exclude_types=set(),

verbose_level=1,

view='text',

**kwargs):

if kwargs:

raise ValueError((

"The following parameter(s) are not valid: %s\n"

"The valid parameters are ignore_order, report_repetition, significant_digits,"

"exclude_paths, exclude_types, verbose_level and view.") % ', '.join(kwargs.keys()))

self.ignore_order = ignore_order

self.report_repetition = report_repetition

self.exclude_paths = set(exclude_paths)

self.exclude_types = set(exclude_types)

self.exclude_types_tuple = tuple(

exclude_types) # we need tuple for checking isinstance

self.hashes = {}

if significant_digits is not None and significant_digits < 0:

raise ValueError(

"significant_digits must be None or a non-negative integer")

self.significant_digits = significant_digits

self.tree = TreeResult()

Verbose.level = verbose_level

root = DiffLevel(t1, t2)

self.__diff(root, parents_ids=frozenset({id(t1)}))

self.tree.cleanup()

if view == 'tree':

self.update(self.tree)

del self.tree

else:

result_text = TextResult(tree_results=self.tree)

result_text.cleanup() # clean up text-style result dictionary

self.update(

result_text

) # be compatible to DeepDiff 2.x if user didn't specify otherwise

# TODO: adding adding functionality

# def __add__(self, other):

# if isinstance(other, DeepDiff):

# result = deepcopy(self)

# result.update(other)

# else:

# result = deepcopy(other)

# for key in REPORT_KEYS:

# if key in self:

# getattr(self, "_do_{}".format(key))(result)

# return result

# __radd__ = __add__

# def _do_iterable_item_added(self, result):

# for item in self['iterable_item_added']:

# pass

def __report_result(self, report_type, level):

"""

if not self.__skip_this(level):

level.report_type = report_type

self.tree[report_type].add(level)

@staticmethod

def __add_to_frozen_set(parents_ids, item_id):

parents_ids = set(parents_ids)

parents_ids.add(item_id)

return frozenset(parents_ids)

@staticmethod

def __dict_from_slots(object):

def unmangle(attribute):

if attribute.startswith('__'):

return '_{type}{attribute}'.format(

type=type(object).__name__,

attribute=attribute

)

return attribute

slots = object.__slots__

if isinstance(slots, strings):

return {slots: getattr(object, unmangle(slots))}

return {i: getattr(object, unmangle(i)) for i in slots}

def __diff_obj(self, level, parents_ids=frozenset({}),

is_namedtuple=False):

"""Difference of 2 objects"""

try:

if is_namedtuple:

t1 = level.t1._asdict()

t2 = level.t2._asdict()

else:

t1 = level.t1.__dict__

t2 = level.t2.__dict__

except AttributeError:

try:

t1 = self.__dict_from_slots(level.t1)

t2 = self.__dict_from_slots(level.t2)

except AttributeError:

self.__report_result('unprocessed', level)

return

self.__diff_dict(

level,

parents_ids,

print_as_attribute=True,

override=True,

override_t1=t1,

override_t2=t2)

def __skip_this(self, level):

"""

skip = False

if self.exclude_paths and level.path() in self.exclude_paths:

skip = True

else:

if isinstance(level.t1, self.exclude_types_tuple) or isinstance(

level.t2, self.exclude_types_tuple):

skip = True

return skip

def __diff_dict(self,

level,

parents_ids=frozenset({}),

print_as_attribute=False,

override=False,

override_t1=None,

override_t2=None):

"""Difference of 2 dictionaries"""

if override:

# for special stuff like custom objects and named tuples we receive preprocessed t1 and t2

# but must not spoil the chain (=level) with it

t1 = override_t1

t2 = override_t2

else:

t1 = level.t1

t2 = level.t2

if print_as_attribute:

item_added_key = "attribute_added"

item_removed_key = "attribute_removed"

rel_class = AttributeRelationship

else:

item_added_key = "dictionary_item_added"

item_removed_key = "dictionary_item_removed"

rel_class = DictRelationship

t1_keys = set(t1.keys())

t2_keys = set(t2.keys())

t_keys_intersect = t2_keys.intersection(t1_keys)

t_keys_added = t2_keys - t_keys_intersect

t_keys_removed = t1_keys - t_keys_intersect

for key in t_keys_added:

change_level = level.branch_deeper(

notpresent,

t2[key],

child_relationship_class=rel_class,

child_relationship_param=key)

self.__report_result(item_added_key, change_level)

for key in t_keys_removed:

change_level = level.branch_deeper(

t1[key],

notpresent,

child_relationship_class=rel_class,

child_relationship_param=key)

self.__report_result(item_removed_key, change_level)

for key in t_keys_intersect: # key present in both dicts - need to compare values

item_id = id(t1[key])

if parents_ids and item_id in parents_ids:

continue

parents_ids_added = self.__add_to_frozen_set(parents_ids, item_id)

# Go one level deeper

next_level = level.branch_deeper(

t1[key],

t2[key],

child_relationship_class=rel_class,

child_relationship_param=key)

self.__diff(next_level, parents_ids_added)

def __diff_set(self, level):

"""Difference of sets"""

t1_hashtable = self.__create_hashtable(level.t1, level)

t2_hashtable = self.__create_hashtable(level.t2, level)

t1_hashes = set(t1_hashtable.keys())

t2_hashes = set(t2_hashtable.keys())

hashes_added = t2_hashes - t1_hashes

hashes_removed = t1_hashes - t2_hashes

items_added = [t2_hashtable[i].item for i in hashes_added]

items_removed = [t1_hashtable[i].item for i in hashes_removed]

for item in items_added:

change_level = level.branch_deeper(

notpresent, item, child_relationship_class=SetRelationship)

self.__report_result('set_item_added', change_level)

for item in items_removed:

change_level = level.branch_deeper(

item, notpresent, child_relationship_class=SetRelationship)

self.__report_result('set_item_removed', change_level)

@staticmethod

def __iterables_subscriptable(t1, t2):

try:

if getattr(t1, '__getitem__') and getattr(t2, '__getitem__'):

return True

else: # pragma: no cover

return False # should never happen

except AttributeError:

return False

def __diff_iterable(self, level, parents_ids=frozenset({})):

"""Difference of iterables"""

# We're handling both subscriptable and non-subscriptable iterables. Which one is it?

subscriptable = self.__iterables_subscriptable(level.t1, level.t2)

if subscriptable:

child_relationship_class = SubscriptableIterableRelationship

else:

child_relationship_class = NonSubscriptableIterableRelationship

for i, (x, y) in enumerate(

zip_longest(

level.t1, level.t2, fillvalue=ListItemRemovedOrAdded)):

if y is ListItemRemovedOrAdded: # item removed completely

change_level = level.branch_deeper(

x,

notpresent,

child_relationship_class=child_relationship_class,

child_relationship_param=i)

self.__report_result('iterable_item_removed', change_level)

elif x is ListItemRemovedOrAdded: # new item added

change_level = level.branch_deeper(

notpresent,

y,

child_relationship_class=child_relationship_class,

child_relationship_param=i)

self.__report_result('iterable_item_added', change_level)

else: # check if item value has changed

item_id = id(x)

if parents_ids and item_id in parents_ids:

continue

parents_ids_added = self.__add_to_frozen_set(parents_ids,

item_id)

# Go one level deeper

next_level = level.branch_deeper(

x,

y,

child_relationship_class=child_relationship_class,

child_relationship_param=i)

self.__diff(next_level, parents_ids_added)

def __diff_str(self, level):

"""Compare strings"""

if level.t1 == level.t2:

return

# do we add a diff for convenience?

do_diff = True

if isinstance(level.t1, bytes_type):

try:

t1_str = level.t1.decode('ascii')

t2_str = level.t2.decode('ascii')

except UnicodeDecodeError:

do_diff = False

else:

t1_str = level.t1

t2_str = level.t2

if do_diff:

if u'\n' in t1_str or u'\n' in t2_str:

diff = difflib.unified_diff(

t1_str.splitlines(), t2_str.splitlines(), lineterm='')

diff = list(diff)

if diff:

level.additional['diff'] = u'\n'.join(diff)

self.__report_result('values_changed', level)

def __diff_tuple(self, level, parents_ids):

# Checking to see if it has _fields. Which probably means it is a named

# tuple.

try:

level.t1._asdict

# It must be a normal tuple

except AttributeError:

self.__diff_iterable(level, parents_ids)

# We assume it is a namedtuple then

else:

self.__diff_obj(level, parents_ids, is_namedtuple=True)

def __create_hashtable(self, t, level):

"""Create hashtable of {item_hash: item}"""

def add_hash(hashes, item_hash, item, i):

if item_hash in hashes:

hashes[item_hash].indexes.append(i)

else:

hashes[item_hash] = IndexedHash([i], item)

hashes = {}

for (i, item) in enumerate(t):

try:

hashes_all = DeepHash(item,

hashes=self.hashes,

significant_digits=self.significant_digits)

item_hash = hashes_all.get(id(item), item)

except Exception as e: # pragma: no cover

logger.warning("Can not produce a hash for %s."

"Not counting this object.\n %s" %

(level.path(), e))

else:

if item_hash is hashes_all.unprocessed: # pragma: no cover

logger.warning("Item %s was not processed while hashing "

"thus not counting this object." %

level.path())

else:

add_hash(hashes, item_hash, item, i)

return hashes

def __diff_iterable_with_contenthash(self, level):

"""Diff of unhashable iterables. Only used when ignoring the order."""

t1_hashtable = self.__create_hashtable(level.t1, level)

t2_hashtable = self.__create_hashtable(level.t2, level)

t1_hashes = set(t1_hashtable.keys())

t2_hashes = set(t2_hashtable.keys())

hashes_added = t2_hashes - t1_hashes

hashes_removed = t1_hashes - t2_hashes

if self.report_repetition:

for hash_value in hashes_added:

for i in t2_hashtable[hash_value].indexes:

change_level = level.branch_deeper(

notpresent,

t2_hashtable[hash_value].item,

child_relationship_class=SubscriptableIterableRelationship, # TODO: that might be a lie!

child_relationship_param=i

) # TODO: what is this value exactly?

self.__report_result('iterable_item_added', change_level)

for hash_value in hashes_removed:

for i in t1_hashtable[hash_value].indexes:

change_level = level.branch_deeper(

t1_hashtable[hash_value].item,

notpresent,

child_relationship_class=SubscriptableIterableRelationship, # TODO: that might be a lie!

child_relationship_param=i)

self.__report_result('iterable_item_removed', change_level)

items_intersect = t2_hashes.intersection(t1_hashes)

for hash_value in items_intersect:

t1_indexes = t1_hashtable[hash_value].indexes

t2_indexes = t2_hashtable[hash_value].indexes