adding ignore_case

Author: seperman

deepdiff/__init__.py

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

deepdiff/base.py

@@ -19,7 +19,8 @@ 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 = [ignore_type_in_groups]
@@ -41,4 +42,7 @@ def get_ignore_types_in_groups(self, ignore_type_in_groups,
         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

@@ -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,10 +93,13 @@ 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.
@@ -303,7 +310,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 +342,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
@@ -56,6 +57,7 @@ def __init__(self,
                  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,
@@ -70,8 +72,10 @@ def __init__(self,
 
         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)
@@ -80,6 +84,8 @@ def __init__(self,
         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
 
@@ -385,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
 
@@ -409,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)
 
@@ -453,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
@@ -582,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 type_in_type_group(item, type_group)

setup.cfg

@@ -19,3 +19,4 @@ exclude = ./data,./src,.svn,CVS,.bzr,.hg,.git,__pycache__
 
 [bumpversion:file:docs/conf.py]
 
+[bumpversion:file:docs/deepdiff/__init__.py]

tests/test_diff_text.py

@@ -209,6 +209,18 @@ def test_string_difference2(self):
         }
         assert result == ddiff
 
+    def test_string_difference_ignore_case(self):
+        t1 = "Hello"
+        t2 = "hello"
+
+        ddiff = DeepDiff(t1, t2)
+        result = {'values_changed': {'root': {'new_value': 'hello', 'old_value': 'Hello'}}}
+        assert result == ddiff
+
+        ddiff = DeepDiff(t1, t2, ignore_string_case=True)
+        result = {}
+        assert result == ddiff
+
     def test_bytes(self):
         t1 = {
             1: 1,
@@ -891,6 +903,29 @@ class ClassB:
         result = {'iterable_item_removed': {'root.__slots__[1]': 'y'}, 'attribute_removed': {'root.__init__', 'root.y'}}
         assert result == ddiff
 
+    def test_custom_object_changes_when_ignore_type_in_groups(self):
+        class ClassA:
+            def __init__(self, x, y):
+                self.x = x
+                self.y = y
+
+        class ClassB:
+            def __init__(self, x):
+                self.x = x
+
+        class ClassC(ClassB):
+            pass
+
+        obj_a = ClassA(1, 2)
+        obj_c = ClassC(3)
+        ddiff = DeepDiff(obj_a, obj_c, ignore_type_in_groups=[(ClassA, ClassB)], ignore_type_subclasses=False)
+        result = {'type_changes': {'root': {'old_type': ClassA, 'new_type': ClassC, 'old_value': obj_a, 'new_value': obj_c}}}
+        assert result == ddiff
+
+        ddiff = DeepDiff(obj_a, obj_c, ignore_type_in_groups=[(ClassA, ClassB)], ignore_type_subclasses=True)
+        result = {'values_changed': {'root.x': {'new_value': 3, 'old_value': 1}}, 'attribute_removed': ['root.y']}
+        assert result == ddiff
+
     def test_custom_objects_slot_in_parent_class_change(self):
         class ClassA:
             __slots__ = ['x']