Merge pull request #137 from seperman/dev

Adding ignore_type_subclasses and ignore_string_case

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 mmh3`
+`pip install 'deepdiff[murmur]'`
 
 Otherwise DeepDiff will be using SHA256 for hashing which is a cryptographic hash and is considerably slower.
 
@@ -48,7 +48,9 @@ DeepDiff gets the difference of 2 objects.
 > - Please take a look at the [DeepDiff docs](deepdiff/diff_doc.rst)
 > - The full documentation can be found on <https://deepdiff.readthedocs.io>
 
-## Examples
+## A few Examples
+
+> Note: This is just a brief overview of what DeepDiff can do. Please visit <https://deepdiff.readthedocs.io> for full documentation.
 
 ### List difference ignoring order or duplicates
 
@@ -157,8 +159,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,12 +409,16 @@ 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 `pip install mmh3`
+And then running
+
+`pip install mmh3`
 
 # ChangeLog
 
+- v4-0-4: Adding ignore_string_case and ignore_type_subclasses
+- v4-0-3: Adding versionbump tool for release
 - v4-0-2: Fixing installation issue where rst files are missing.
 - v4-0-1: Fixing installation Tarball missing requirements.txt . DeepDiff v4+ should not show up as pip installable for Py2. Making Murmur3 installation optional.
 - v4-0-0: Ending Python 2 support, Adding more functionalities and documentation for DeepHash. Switching to Pytest for testing. Switching to Murmur3 128bit for hashing. Fixing classes which inherit from classes with slots didn't have all of their slots compared. Renaming ContentHash to DeepHash. Adding exclude by path and regex path to DeepHash. Adding ignore_type_in_groups. Adding match_string to DeepSearch. Adding Timedelta object diffing.
@@ -448,6 +453,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

@@ -1,6 +1,5 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-import os
 import logging
 from collections import Iterable
 from collections import MutableMapping
@@ -9,16 +8,15 @@
 from hashlib import sha1, sha256
 
 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_set_else_none, get_doc,
                              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__)
 
 try:
     import mmh3
 except ImportError:
-    logger.warning('Can not find Murmur3 hashing installed. Switching to SHA256 as the default hash. Refer to https://github.com/seperman/deepdiff#murmur3 for more info.')
     mmh3 = False
 
 UNPROCESSED = 'unprocessed'
@@ -34,7 +32,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,11 +41,12 @@ 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
 
 
-with open(os.path.join(current_dir, 'deephash_doc.rst'), 'r') as doc_file:
-    doc = doc_file.read()
+doc = get_doc('deephash_doc.rst')
 
 
 class DeepHash(dict, Base):
@@ -67,14 +66,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 +90,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 +223,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 +308,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 +340,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/deephash_doc.rst

@@ -10,7 +10,7 @@ At the core of it, DeepHash is a deterministic serialization of your object into
 can be passed to a hash function. By default it uses Murmur 3 128 bit hash function which is a
 fast, non-cryptographic hashing function. You have the option to pass any another hashing function to be used instead.
 
-If it can't find Murmur3 package (mmh3) installed, it uses Python's built-in SHA256 for hashing which is considerably slower than Murmur3. So it is advised that you install Murmur3 by running `pip install mmh3`
+If it can't find Murmur3 package (mmh3) installed, it uses Python's built-in SHA256 for hashing which is considerably slower than Murmur3. So it is advised that you install Murmur3 by running `pip install 'deepdiff[murmur]`
 
 **Import**
     >>> from deepdiff import DeepHash
@@ -138,6 +138,15 @@ ignore_type_in_groups example with custom objects:
     >>> d1[burrito] == d2[taco]
     True
 
+
+ignore_type_subclasses
+    Use ignore_type_subclasses=True so when ignoring type (class), the subclasses of that class are ignored too.
+
+
+ignore_string_case
+    Whether to be case-sensitive or not when comparing strings. By settings ignore_string_case=False, strings will be compared case-insensitively.
+
+
 **Returns**
     A dictionary of {item: item hash}.
     If your object is nested, it will build hashes of all the objects it contains too.
@@ -161,43 +170,87 @@ But with DeepHash:
     >>> DeepHash(obj)
     {1: 234041559348429806012597903916437026784, 2: 148655924348182454950690728321917595655, 'a': 119173504597196970070553896747624927922, 'b': 4994827227437929991738076607196210252, '!>*id4488569408': 32452838416412500686422093274247968754}
 
-So what is exactly the hash of obj in this case?
-DeepHash is calculating the hash of the obj and any other object that obj contains.
-The output of DeepHash is a dictionary of object IDs to their hashes.
-In order to get the hash of obj itself, you need to use the object (or the id of object) to get its hash:
+    So what is exactly the hash of obj in this case?
+    DeepHash is calculating the hash of the obj and any other object that obj contains.
+    The output of DeepHash is a dictionary of object IDs to their hashes.
+    In order to get the hash of obj itself, you need to use the object (or the id of object) to get its hash:
     >>> hashes = DeepHash(obj)
     >>> hashes[obj]
     34150898645750099477987229399128149852
 
-Which you can write as:
+    Which you can write as:
     >>> hashes = DeepHash(obj)[obj]
 
-At first it might seem weird why DeepHash(obj)[obj] but remember that DeepHash(obj) is a dictionary of hashes of all other objects that obj contains too.
+    At first it might seem weird why DeepHash(obj)[obj] but remember that DeepHash(obj) is a dictionary of hashes of all other objects that obj contains too.
 
-The result hash is 34150898645750099477987229399128149852 which is generated by
-Murmur 3 128bit hashing algorithm. If you prefer to use another hashing algorithm, you can pass it using the hasher parameter. Read more about Murmur3 here: https://en.wikipedia.org/wiki/MurmurHash
+    The result hash is 34150898645750099477987229399128149852 which is generated by
+    Murmur 3 128bit hashing algorithm. If you prefer to use another hashing algorithm, you can pass it using the hasher parameter. Read more about Murmur3 here: https://en.wikipedia.org/wiki/MurmurHash
 
-If you do a deep copy of obj, it should still give you the same hash:
+    If you do a deep copy of obj, it should still give you the same hash:
     >>> from copy import deepcopy
     >>> obj2 = deepcopy(obj)
     >>> DeepHash(obj2)[obj2]
     34150898645750099477987229399128149852
 
-Note that by default DeepHash will include string type differences. So if your strings were bytes:
+    Note that by default DeepHash will include string type differences. So if your strings were bytes:
     >>> obj3 = {1: 2, b'a': b'b'}
     >>> DeepHash(obj3)[obj3]
     64067525765846024488103933101621212760
 
-But if you want the same hash if string types are different, set ignore_string_type_changes to True:
+    But if you want the same hash if string types are different, set ignore_string_type_changes to True:
     >>> DeepHash(obj3, ignore_string_type_changes=True)[obj3]
     34150898645750099477987229399128149852
 
-ignore_numeric_type_changes is by default False too.
+    ignore_numeric_type_changes is by default False too.
     >>> obj1 = {4:10}
     >>> obj2 = {4.0: Decimal(10.0)}
     >>> DeepHash(obj1)[4] == DeepHash(obj2)[4.0]
     False
 
-But by setting it to True, we can get the same hash.
+    But by setting it to True, we can get the same hash.
     >>> DeepHash(obj1, ignore_numeric_type_changes=True)[4] == DeepHash(obj2, ignore_numeric_type_changes=True)[4.0]
     True
+
+
+ignore_type_subclasses
+    Use ignore_type_subclasses=True so when ignoring type (class), the subclasses of that class are ignored too.
+
+    >>> from deepdiff import DeepHash
+    >>>
+    >>> class ClassB:
+    ...     def __init__(self, x):
+    ...         self.x = x
+    ...     def __repr__(self):
+    ...         return "obj b"
+    ...
+    >>>
+    >>> class ClassC(ClassB):
+    ...     def __repr__(self):
+    ...         return "obj c"
+    ...
+    >>> obj_b = ClassB(1)
+    >>> obj_c = ClassC(1)
+    >>>
+    >>> # Since these 2 objects are from 2 different classes, the hashes are different by default.
+    ... # ignore_type_in_groups is set to [(ClassB, )] which means to ignore any type conversion between
+    ... # objects of classB and itself which does not make sense but it illustrates a better point when
+    ... # ignore_type_subclasses is set to be True.
+    ... hashes_b = DeepHash(obj_b, ignore_type_in_groups=[(ClassB, )])
+    >>> hashes_c = DeepHash(obj_c, ignore_type_in_groups=[(ClassB, )])
+    >>> hashes_b[obj_b] != hashes_c[obj_c]
+    True
+    >>>
+    >>> # Hashes of these 2 objects will be the same when ignore_type_subclasses is set to True
+    ... hashes_b = DeepHash(obj_b, ignore_type_in_groups=[(ClassB, )], ignore_type_subclasses=True)
+    >>> hashes_c = DeepHash(obj_c, ignore_type_in_groups=[(ClassB, )], ignore_type_subclasses=True)
+    >>> hashes_b[obj_b] == hashes_c[obj_c]
+    True
+
+ignore_string_case
+    Whether to be case-sensitive or not when comparing strings. By settings ignore_string_case=False, strings will be compared case-insensitively.
+
+    >>> from deepdiff import DeepHash
+    >>> DeepHash('hello')['hello'] == DeepHash('heLLO')['heLLO']
+    False
+    >>> DeepHash('hello', ignore_string_case=True)['hello'] == DeepHash('heLLO', ignore_string_case=True)['heLLO']
+    True