Merge branch 'dev' into murmur3_extra

Author: seperman

README.md

@@ -1,4 +1,4 @@
-# DeepDiff v 4.0.2
+# DeepDiff v 4.0.4
 
 <!-- ![Downloads](https://img.shields.io/pypi/dm/deepdiff.svg?style=flat) -->
 ![Python Versions](https://img.shields.io/pypi/pyversions/deepdiff.svg?style=flat)
@@ -23,11 +23,11 @@ Tested on Python 3.4, 3.5, 3.6, 3.7, Pypy3
 
 ### Install from PyPi:
 
-    `pip install deepdiff`
+`pip install deepdiff`
 
 DeepDiff prefers to use Murmur3 for hashing. However you have to manually install Murmur3 by running:
 
-    `pip install 'deepdiff[murmur]'`
+`pip install 'deepdiff[murmur]'`
 
 Otherwise DeepDiff will be using SHA256 for hashing which is a cryptographic hash and is considerably slower.
 
@@ -157,8 +157,7 @@ Digits **after** the decimal point. Internally it uses "{:.Xf}".format(Your Numb
                          'new_value': 3.0,
                          'old_type': <class 'int'>,
                          'old_value': 3}}}
->>> ddiff = DeepDiff(t1, t2, ignore_type_in_groups=True)
->>> pprint(ddiff, indent=2)
+>>> ddiff = DeepDiff(t1, t2, ignore_type_in_groups=[(int, float)])
 {}
 ```
 
@@ -408,9 +407,11 @@ On MacOS Mojave some user experience difficulty when installing Murmur3.
 
 The problem can be solved by running:
 
-    `xcode-select --install`
+`xcode-select --install`
+
+And then running
 
-And then running `pip install mmh3`
+`pip install mmh3`
 
 # ChangeLog
 
@@ -448,6 +449,16 @@ And then running `pip install mmh3`
 - v0-5-6: Adding slots support
 - v0-5-5: Adding loop detection
 
+# Releases
+
+We use bump2version to bump and tag releases.
+
+```bash
+git checkout master && git pull
+bumpversion {patch|minor|major}
+git push && git push --tags
+```
+
 # Contribute
 
 1. Please make your PR against the dev branch

deepdiff/__init__.py

@@ -1,11 +1,12 @@
-"""This module offers the DeepDiff, DeepSearch, grep and DeepHash classes."""
-# flake8: noqa
-__version__ = '4.0.2'
-import logging
-
-if __name__ == '__main__':
-    logging.basicConfig(format='%(asctime)s %(levelname)8s %(message)s')
-
-from .diff import DeepDiff
-from .search import DeepSearch, grep
-from .deephash import DeepHash
+"""This module offers the DeepDiff, DeepSearch, grep and DeepHash classes."""
+# flake8: noqa
+__version__ = '4.0.4'
+import logging
+
+if __name__ == '__main__':
+    logging.basicConfig(format='%(asctime)s %(levelname)8s %(message)s')
+
+
+from .diff import DeepDiff
+from .search import DeepSearch, grep
+from .deephash import DeepHash

deepdiff/base.py

@@ -19,19 +19,30 @@ def get_significant_digits(self, significant_digits, ignore_numeric_type_changes
 
     def get_ignore_types_in_groups(self, ignore_type_in_groups,
                                    ignore_string_type_changes,
-                                   ignore_numeric_type_changes):
+                                   ignore_numeric_type_changes,
+                                   ignore_type_subclasses):
         if ignore_type_in_groups:
             if isinstance(ignore_type_in_groups[0], type):
-                ignore_type_in_groups = [OrderedSet(ignore_type_in_groups)]
-            else:
-                ignore_type_in_groups = list(map(OrderedSet, ignore_type_in_groups))
+                ignore_type_in_groups = [ignore_type_in_groups]
         else:
             ignore_type_in_groups = []
 
+        result = []
+        for item_group in ignore_type_in_groups:
+            new_item_group = OrderedSet()
+            for item in item_group:
+                item = type(item) if item is None or not isinstance(item, type) else item
+                new_item_group.add(item)
+            result.append(new_item_group)
+        ignore_type_in_groups = result
+
         if ignore_string_type_changes and self.strings not in ignore_type_in_groups:
             ignore_type_in_groups.append(OrderedSet(self.strings))
 
         if ignore_numeric_type_changes and self.numbers not in ignore_type_in_groups:
             ignore_type_in_groups.append(OrderedSet(self.numbers))
 
+        if ignore_type_subclasses:
+            ignore_type_in_groups = list(map(tuple, ignore_type_in_groups))
+
         return ignore_type_in_groups

deepdiff/deephash.py

@@ -11,7 +11,7 @@
 from deepdiff.helper import (strings, numbers, unprocessed, not_hashed, add_to_frozen_set,
                              convert_item_or_items_into_set_else_none, current_dir,
                              convert_item_or_items_into_compiled_regexes_else_none,
-                             get_id)
+                             get_id, type_is_subclass_of_type_group, type_in_type_group)
 from deepdiff.base import Base
 logger = logging.getLogger(__name__)
 
@@ -34,7 +34,7 @@
 ZERO_DECIMAL_CHARACTERS = set("-0.")
 
 
-def prepare_string_for_hashing(obj, ignore_string_type_changes=False):
+def prepare_string_for_hashing(obj, ignore_string_type_changes=False, ignore_string_case=False):
     """
     Clean type conversions
     """
@@ -43,6 +43,8 @@ def prepare_string_for_hashing(obj, ignore_string_type_changes=False):
         obj = obj.decode('utf-8')
     if not ignore_string_type_changes:
         obj = KEY_TO_VAL_STR.format(original_type, obj)
+    if ignore_string_case:
+        obj = obj.lower()
     return obj
 
 
@@ -67,14 +69,16 @@ def __init__(self,
                  ignore_type_in_groups=None,
                  ignore_string_type_changes=False,
                  ignore_numeric_type_changes=False,
+                 ignore_type_subclasses=False,
+                 ignore_string_case=False,
                  **kwargs):
         if kwargs:
             raise ValueError(
                 ("The following parameter(s) are not valid: %s\n"
                  "The valid parameters are obj, hashes, exclude_types,"
                  "exclude_paths, exclude_regex_paths, hasher, ignore_repetition,"
                  "significant_digits, apply_hash, ignore_type_in_groups, ignore_string_type_changes,"
-                 "ignore_numeric_type_changes") % ', '.join(kwargs.keys()))
+                 "ignore_numeric_type_changes, ignore_type_subclasses, ignore_string_case") % ', '.join(kwargs.keys()))
         self.obj = obj
         exclude_types = set() if exclude_types is None else set(exclude_types)
         self.exclude_types_tuple = tuple(exclude_types)  # we need tuple for checking isinstance
@@ -89,14 +93,18 @@ def __init__(self,
 
         self.significant_digits = self.get_significant_digits(significant_digits, ignore_numeric_type_changes)
         self.ignore_type_in_groups = self.get_ignore_types_in_groups(
-            ignore_type_in_groups,
-            ignore_string_type_changes, ignore_numeric_type_changes)
+            ignore_type_in_groups=ignore_type_in_groups,
+            ignore_string_type_changes=ignore_string_type_changes,
+            ignore_numeric_type_changes=ignore_numeric_type_changes,
+            ignore_type_subclasses=ignore_type_subclasses)
         self.ignore_string_type_changes = ignore_string_type_changes
         self.ignore_numeric_type_changes = ignore_numeric_type_changes
+        self.ignore_string_case = ignore_string_case
         # makes the hash return constant size result if true
         # the only time it should be set to False is when
         # testing the individual hash functions for different types of objects.
         self.apply_hash = apply_hash
+        self.type_check_func = type_is_subclass_of_type_group if ignore_type_subclasses else type_in_type_group
 
         self._hash(obj, parent="root", parents_ids=frozenset({get_id(obj)}))
 
@@ -218,7 +226,7 @@ def _prep_dict(self, obj, parent, parents_ids=EMPTY_FROZENSET, print_as_attribut
             type_ = original_type or type(obj)
             type_str = type_.__name__
             for type_group in self.ignore_type_in_groups:
-                if type_ in type_group:
+                if self.type_check_func(type_, type_group):
                     type_str = ','.join(map(lambda x: x.__name__, type_group))
                     break
         else:
@@ -303,7 +311,9 @@ def _hash(self, obj, parent, parents_ids=EMPTY_FROZENSET):
             result = 'NONE'
 
         elif isinstance(obj, strings):
-            result = prepare_string_for_hashing(obj, ignore_string_type_changes=self.ignore_string_type_changes)
+            result = prepare_string_for_hashing(
+                obj, ignore_string_type_changes=self.ignore_string_type_changes,
+                ignore_string_case=self.ignore_string_case)
 
         elif isinstance(obj, numbers):
             result = self._prep_number(obj)
@@ -333,7 +343,9 @@ def _hash(self, obj, parent, parents_ids=EMPTY_FROZENSET):
             if isinstance(obj, strings):
                 result_cleaned = result
             else:
-                result_cleaned = prepare_string_for_hashing(result, ignore_string_type_changes=self.ignore_string_type_changes)
+                result_cleaned = prepare_string_for_hashing(
+                    result, ignore_string_type_changes=self.ignore_string_type_changes,
+                    ignore_string_case=self.ignore_string_case)
             result = self.hasher(result_cleaned)
 
         # It is important to keep the hash of all objects.

deepdiff/diff.py

@@ -23,7 +23,8 @@
 from deepdiff.helper import (strings, bytes_type, numbers, ListItemRemovedOrAdded, notpresent,
                              IndexedHash, Verbose, unprocessed, json_convertor_default, add_to_frozen_set,
                              convert_item_or_items_into_set_else_none, get_type,
-                             convert_item_or_items_into_compiled_regexes_else_none, current_dir)
+                             convert_item_or_items_into_compiled_regexes_else_none, current_dir,
+                             type_is_subclass_of_type_group, type_in_type_group)
 from deepdiff.model import RemapDict, ResultDict, TextResult, TreeResult, DiffLevel
 from deepdiff.model import DictRelationship, AttributeRelationship
 from deepdiff.model import SubscriptableIterableRelationship, NonSubscriptableIterableRelationship, SetRelationship
@@ -55,6 +56,8 @@ def __init__(self,
                  ignore_type_in_groups=None,
                  ignore_string_type_changes=False,
                  ignore_numeric_type_changes=False,
+                 ignore_type_subclasses=False,
+                 ignore_string_case=False,
                  verbose_level=1,
                  view=TEXT_VIEW,
                  hasher=None,
@@ -64,20 +67,25 @@ def __init__(self,
                 "The following parameter(s) are not valid: %s\n"
                 "The valid parameters are ignore_order, report_repetition, significant_digits, "
                 "exclude_paths, exclude_types, exclude_regex_paths, ignore_type_in_groups, "
-                "ignore_string_type_changes, ignore_numeric_type_changes, verbose_level, view, "
-                "and hasher.") % ', '.join(kwargs.keys()))
+                "ignore_string_type_changes, ignore_numeric_type_changes, ignore_type_subclasses, "
+                "verbose_level, view, and hasher.") % ', '.join(kwargs.keys()))
 
         self.ignore_order = ignore_order
         self.ignore_type_in_groups = self.get_ignore_types_in_groups(
-            ignore_type_in_groups,
-            ignore_string_type_changes, ignore_numeric_type_changes)
+            ignore_type_in_groups=ignore_type_in_groups,
+            ignore_string_type_changes=ignore_string_type_changes,
+            ignore_numeric_type_changes=ignore_numeric_type_changes,
+            ignore_type_subclasses=ignore_type_subclasses)
         self.report_repetition = report_repetition
         self.exclude_paths = convert_item_or_items_into_set_else_none(exclude_paths)
         self.exclude_regex_paths = convert_item_or_items_into_compiled_regexes_else_none(exclude_regex_paths)
         self.exclude_types = set(exclude_types) if exclude_types else None
         self.exclude_types_tuple = tuple(exclude_types) if exclude_types else None  # we need tuple for checking isinstance
         self.ignore_string_type_changes = ignore_string_type_changes
         self.ignore_numeric_type_changes = ignore_numeric_type_changes
+        self.ignore_type_subclasses = ignore_type_subclasses
+        self.type_check_func = type_is_subclass_of_type_group if ignore_type_subclasses else type_in_type_group
+        self.ignore_string_case = ignore_string_case
         self.hashes = {}
         self.hasher = hasher
 
@@ -383,6 +391,10 @@ def __diff_iterable(self, level, parents_ids=frozenset({})):
 
     def __diff_str(self, level):
         """Compare strings"""
+        if self.ignore_string_case:
+            level.t1 = level.t1.lower()
+            level.t2 = level.t2.lower()
+
         if type(level.t1) == type(level.t2) and level.t1 == level.t2:
             return
 
@@ -407,12 +419,12 @@ def __diff_str(self, level):
             return
 
         if do_diff:
-            if u'\n' in t1_str or u'\n' in t2_str:
+            if '\n' in t1_str or '\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)
+                    level.additional['diff'] = '\n'.join(diff)
 
         self.__report_result('values_changed', level)
 
@@ -451,6 +463,8 @@ def __create_hashtable(self, t, level):
                                       ignore_string_type_changes=self.ignore_string_type_changes,
                                       ignore_numeric_type_changes=self.ignore_numeric_type_changes,
                                       ignore_type_in_groups=self.ignore_type_in_groups,
+                                      ignore_type_subclasses=self.ignore_type_subclasses,
+                                      ignore_string_case=self.ignore_string_case
                                       )
                 item_hash = hashes_all[item]
             except Exception as e:  # pragma: no cover
@@ -580,7 +594,7 @@ def __diff(self, level, parents_ids=frozenset({})):
         if get_type(level.t1) != get_type(level.t2):
             report_type_change = True
             for type_group in self.ignore_type_in_groups:
-                if get_type(level.t1) in type_group and get_type(level.t2) in type_group:
+                if self.type_check_func(level.t1, type_group) and self.type_check_func(level.t2, type_group):
                     report_type_change = False
                     break
             if report_type_change:

deepdiff/helper.py

@@ -195,3 +195,11 @@ def get_type(obj):
     Get the type of object or if it is a class, return the class itself.
     """
     return obj if type(obj) is type else type(obj)
+
+
+def type_in_type_group(item, type_group):
+    return get_type(item) in type_group
+
+
+def type_is_subclass_of_type_group(item, type_group):
+    return isinstance(item, type_group) or issubclass(item, type_group) or type_in_type_group(item, type_group)

docs/conf.py

@@ -60,9 +60,9 @@
 # built documents.
 #
 # The short X.Y version.
-version = '4.0.2'
+version = '4.0.4'
 # The full version, including alpha/beta/rc tags.
-release = '4.0.2'
+release = '4.0.4'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

docs/index.rst

@@ -4,7 +4,7 @@
    contain the root `toctree` directive.
 
 
-DeepDiff 4.0.2 documentation!
+DeepDiff 4.0.4 documentation!
 =============================
 
 **DeepDiff: Deep Difference of dictionaries, iterables, strings and other objects. It will recursively look for all the changes.**

pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+addopts = --pdbcls=IPython.terminal.debugger:Pdb

requirements-dev.txt

@@ -1,5 +1,7 @@
 -r requirements.txt
-pytest==4.0.1
-pytest-cov==2.6.0
-numpy==1.15.4
+pytest==4.3.1
+pytest-cov==2.6.1
+numpy==1.16.2
 mmh3==2.5.1
+ipdb==0.11
+bump2version==0.5.10