updating docs

Author: seperman

README.md

@@ -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
 
@@ -415,6 +417,8 @@ And then running
 
 # 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.

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

deepdiff/diff_doc.rst

@@ -69,6 +69,12 @@ ignore_numeric_type_changes: Boolean, default = False
 ignore_type_in_groups: Tuple or List of Tuples, default = None
     ignores types when t1 and t2 are both within the same type group.
 
+ignore_type_subclasses: Boolean, default = False
+    ignore type (class) changes when dealing with the subclasses of classes that were marked to be ignored.
+
+ignore_string_case: Boolean, default = False
+    Whether to be case-sensitive or not when comparing strings. By settings ignore_string_case=False, strings will be compared case-insensitively.
+
 **Returns**
 
     A DeepDiff object that has already calculated the difference of the 2 items.
@@ -322,31 +328,27 @@ Exclude certain types from comparison:
     {}
 
 ignore_type_in_groups
+    Ignore type changes between members of groups of types. For example if you want to ignore type changes between float and decimals etc. Note that this is a more granular feature. Most of the times the shortcuts provided to you are enough.
+    The shortcuts are ignore_string_type_changes which by default is False and ignore_numeric_type_changes which is by default False. You can read more about those shortcuts in this page. ignore_type_in_groups gives you more control compared to the shortcuts.
 
-Ignore type changes between members of groups of types. For example if you want to ignore type changes between float and decimals etc. Note that this is a more granular feature. Most of the times the shortcuts provided to you are enough.
-The shortcuts are ignore_string_type_changes which by default is False and ignore_numeric_type_changes which is by default False. You can read more about those shortcuts in this page. ignore_type_in_groups gives you more control compared to the shortcuts.
+    For example lets say you have specifically str and byte datatypes to be ignored for type changes. Then you have a couple of options:
 
-For example lets say you have specifically str and byte datatypes to be ignored for type changes. Then you have a couple of options:
+    1. Set ignore_string_type_changes=True.
+    2. Or set ignore_type_in_groups=[(str, bytes)]. Here you are saying if we detect one type to be str and the other one bytes, do not report them as type change. It is exactly as passing ignore_type_in_groups=[DeepDiff.strings] or ignore_type_in_groups=DeepDiff.strings .
 
-1. Set ignore_string_type_changes=True.
-2. Or set ignore_type_in_groups=[(str, bytes)]. Here you are saying if we detect one type to be str and the other one bytes, do not report them as type change. It is exactly as passing ignore_type_in_groups=[DeepDiff.strings] or ignore_type_in_groups=DeepDiff.strings .
+    Now what if you want also typeA and typeB to be ignored when comparing agains each other?
 
-Now what if you want also typeA and typeB to be ignored when comparing agains each other?
+    1. ignore_type_in_groups=[DeepDiff.strings, (typeA, typeB)]
+    2. or ignore_type_in_groups=[(str, bytes), (typeA, typeB)]
 
-1. ignore_type_in_groups=[DeepDiff.strings, (typeA, typeB)]
-2. or ignore_type_in_groups=[(str, bytes), (typeA, typeB)]
-
-ignore_string_type_changes
-Default: False
+ignore_string_type_changes Default: False
     >>> DeepDiff(b'hello', 'hello', ignore_string_type_changes=True)
     {}
     >>> DeepDiff(b'hello', 'hello')
     {'type_changes': {'root': {'old_type': <class 'bytes'>, 'new_type': <class 'str'>, 'old_value': b'hello', 'new_value': 'hello'}}}
 
-ignore_numeric_type_changes
-Default: False
-
-Ignore Type Number - Dictionary that contains float and integer:
+ignore_numeric_type_changes Default: False
+    Ignore Type Number - Dictionary that contains float and integer
     >>> from deepdiff import DeepDiff
     >>> from pprint import pprint
     >>> t1 = {1: 1, 2: 2.22}
@@ -361,7 +363,7 @@ Ignore Type Number - Dictionary that contains float and integer:
     >>> pprint(ddiff, indent=2)
     {}
 
-Ignore Type Number - List that contains float and integer:
+Ignore Type Number - List that contains float and integer
     >>> from deepdiff import DeepDiff
     >>> from pprint import pprint
     >>> t1 = [1, 2, 3]
@@ -384,7 +386,7 @@ Ignore Type Number - List that contains float and integer:
     >>> pprint(ddiff, indent=2)
     {}
 
-You can pass a list of tuples or list of lists if you have various type groups. When t1 and t2 both fall under one of these type groups, the type change will be ignored. DeepDiff already comes with 2 groups: DeepDiff.strings and DeepDiff.numbers . If you want to pass both:
+    You can pass a list of tuples or list of lists if you have various type groups. When t1 and t2 both fall under one of these type groups, the type change will be ignored. DeepDiff already comes with 2 groups: DeepDiff.strings and DeepDiff.numbers . If you want to pass both:
     >>> ignore_type_in_groups = [DeepDiff.strings, DeepDiff.numbers]
 
 
@@ -411,6 +413,39 @@ ignore_type_in_groups example with custom objects:
     {}
 
 
+ignore_type_subclasses
+    Use ignore_type_subclasses=True so when ignoring type (class), the subclasses of that class are ignored too.
+
+    >>> from deepdiff import DeepDiff
+    >>> 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)
+    >>>
+    >>> DeepDiff(obj_a, obj_c, ignore_type_in_groups=[(ClassA, ClassB)], ignore_type_subclasses=False)
+    {'type_changes': {'root': {'old_type': <class '__main__.ClassA'>, 'new_type': <class '__main__.ClassC'>, 'old_value': <__main__.ClassA object at 0x10076a2e8>, 'new_value': <__main__.ClassC object at 0x10082f630>}}}
+    >>>
+    >>> DeepDiff(obj_a, obj_c, ignore_type_in_groups=[(ClassA, ClassB)], ignore_type_subclasses=True)
+    {'values_changed': {'root.x': {'new_value': 3, 'old_value': 1}}, 'attribute_removed': [root.y]}
+
+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.
+
+    >>> DeepDiff(t1='Hello', t2='heLLO')
+    {'values_changed': {'root': {'new_value': 'heLLO', 'old_value': 'Hello'}}}
+    >>> DeepDiff(t1='Hello', t2='heLLO', ignore_string_case=True)
+    {}
+
 **Tree View**
 
 Starting the version 3 You can chooe the view into the deepdiff results.

docs/conf.py

@@ -52,7 +52,7 @@
 
 # General information about the project.
 project = 'DeepDiff'
-copyright = '2015-2017, Sep Dehpour'
+copyright = '2015-2019, Sep Dehpour'
 author = 'Sep Dehpour'
 
 # The version info for the project you're documenting, acts as replacement for

docs/index.rst

@@ -27,7 +27,7 @@ Install from PyPi::
 
 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.
 
@@ -51,7 +51,7 @@ Read The DeepDiff details in:
 
 :doc:`/diff`
 
-Short introduction::
+Short introduction
 
 Supported data types
 ~~~~~~~~~~~~~~~~~~~~
@@ -281,6 +281,8 @@ Indices and tables
 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.

tests/test_diff_text.py

@@ -914,7 +914,8 @@ def __init__(self, x):
                 self.x = x
 
         class ClassC(ClassB):
-            pass
+            def __repr__(self):
+                return "obj c"
 
         obj_a = ClassA(1, 2)
         obj_c = ClassC(3)

tests/test_hash.py

@@ -349,17 +349,19 @@ class ClassC(ClassB):
         pass
 
     obj_a = ClassA(1, 2)
+    obj_b = ClassB(1, 2)
     obj_c = ClassC(1, 2)
 
     burrito = Burrito()
     taco = Taco()
 
     @pytest.mark.parametrize("t1, t2, ignore_type_in_groups, ignore_type_subclasses, is_qual", [
-        # (taco, burrito, [], False, False),
-        # (taco, burrito, [(Taco, Burrito)], False, True),
-        # ([taco], [burrito], [(Taco, Burrito)], False, True),
-        # ([obj_a], [obj_c], [(ClassA, ClassB)], False, False),
+        (taco, burrito, [], False, False),
+        (taco, burrito, [(Taco, Burrito)], False, True),
+        ([taco], [burrito], [(Taco, Burrito)], False, True),
+        ([obj_a], [obj_c], [(ClassA, ClassB)], False, False),
         ([obj_a], [obj_c], [(ClassA, ClassB)], True, True),
+        ([obj_b], [obj_c], [(ClassB, )], True, True),
     ])
     def test_objects_with_same_content(self, t1, t2, ignore_type_in_groups, ignore_type_subclasses, is_qual):