docs

Author: seperman

deepdiff/deephash_doc.rst

@@ -132,6 +132,7 @@ If you try to hash it:
     TypeError: unhashable type: 'dict'
 
 But with DeepHash:
+
     >>> from deepdiff import DeepHash
     >>> obj = {1: 2, 'a': 'b'}
     >>> DeepHash(obj)
@@ -141,11 +142,13 @@ But with DeepHash:
     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:
+
     >>> 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.
@@ -154,27 +157,32 @@ But with DeepHash:
     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:
+
     >>> 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:
+
     >>> 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:
+
     >>> DeepHash(obj3, ignore_string_type_changes=True)[obj3]
     34150898645750099477987229399128149852
 
     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.
+
     >>> DeepHash(obj1, ignore_numeric_type_changes=True)[4] == DeepHash(obj2, ignore_numeric_type_changes=True)[4.0]
     True
 
@@ -184,6 +192,7 @@ number_format_notation: String, default = "f"
 
 ignore_string_type_changes: Boolean, default = True
     By setting it to True, both the string and bytes of hello return the same hash.
+
     >>> DeepHash(b'hello', ignore_string_type_changes=True)
     {b'hello': 221860156526691709602818861774599422448}
     >>> DeepHash('hello', ignore_string_type_changes=True)
@@ -203,11 +212,13 @@ ignore_numeric_type_changes: Boolean, default = False
     231678797214551245419120414857003063149
 
     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:
+
     >>> from deepdiff import DeepDiff
     >>> ignore_type_in_groups = [DeepDiff.strings, DeepDiff.numbers]
 
 
 ignore_type_in_groups example with custom objects:
+
     >>> class Burrito:
     ...     bread = 'flour'
     ...     def __init__(self):
@@ -277,6 +288,7 @@ ignore_string_case
 
 number_format_notation : string, default="f"
     When numbers are converted to the string, you have the choices between "f" as fixed point and "e" as scientific notation:
+
     >>> t1=10002
     >>> t2=10004
     >>> t1_hash = DeepHash(t1, significant_digits=3, number_format_notation="f")
@@ -292,3 +304,21 @@ number_format_notation : string, default="f"
     >>>
     >>> t1_hash[t1] == t2_hash[t2]
     True
+
+Defining your own number_to_string_func
+    Lets say you want the hash of numbers below 100 to be the same for some reason.
+
+    >>> from deepdiff import DeepHash
+    >>> from deepdiff.helper import number_to_string
+    >>> def custom_number_to_string(number, *args, **kwargs):
+    ...     number = 100 if number < 100 else number
+    ...     return number_to_string(number, *args, **kwargs)
+    ...
+    >>> t1 = [10, 12, 100000]
+    >>> t2 = [50, 63, 100021]
+    >>> t1_hash = DeepHash(t1, significant_digits=3, number_format_notation="e", number_to_string_func=custom_number_to_string)
+    >>> t2_hash = DeepHash(t2, significant_digits=3, number_format_notation="e", number_to_string_func=custom_number_to_string)
+    >>> t1_hash[t1] == t2_hash[t2]
+    True
+
+    So both lists produced the same hash thanks to the low significant digits for 100000 vs 100021 and also the custom_number_to_string that converted all numbers below 100 to be 100!

deepdiff/diff_doc.rst

@@ -310,26 +310,22 @@ Approximate number comparison (significant_digits after the decimal point in sci
     {}
 
 Defining your own number_to_string_func
-    Lets say you want the numbers comparison do it in logarithmic scale and in scientific notation.
-    >>> import math
+    Lets say you want the numbers comparison happen only for numbers above 100 for some reason.
+
     >>> from deepdiff import DeepDiff
     >>> from deepdiff.helper import number_to_string
-    >>>
-    >>>
-    >>> def log_number_to_string(number, *args, **kwargs):
-    ...     number = math.log(number)
+    >>> def custom_number_to_string(number, *args, **kwargs):
+    ...     number = 100 if number < 100 else number
     ...     return number_to_string(number, *args, **kwargs)
     ...
-    >>>
-    >>> DeepDiff(100000, 100021, significant_digits=4, number_format_notation="e", number_to_string_func=log_number_to_string)
+    >>> t1 = [10, 12, 100000]
+    >>> t2 = [50, 63, 100021]
+    >>> DeepDiff(t1, t2, significant_digits=3, number_format_notation="e")
+    {'values_changed': {'root[0]': {'new_value': 50, 'old_value': 10}, 'root[1]': {'new_value': 63, 'old_value': 12}}}
+    >>> 
+    >>> DeepDiff(t1, t2, significant_digits=3, number_format_notation="e",
+    ...          number_to_string_func=custom_number_to_string)
     {}
-    >>>
-    >>> t1 = [10, 100000]
-    >>> t2 = [11, 100021]
-    >>>
-    >>> DeepDiff(t1, t2, significant_digits=4, number_format_notation="e", number_to_string_func=log_number_to_string)
-    {'values_changed': {'root[0]': {'new_value': 11, 'old_value': 10}}}
-
 
 .. note::
     All the examples for the text view work for the tree view too.

tests/test_diff_text.py

@@ -1392,7 +1392,7 @@ def custom_number_to_string(number, *args, **kwargs):
             number = 100 if number < 100 else number
             return number_to_string(number, *args, **kwargs)
 
-        ddiff = DeepDiff(100000, 100021, significant_digits=3, number_format_notation="e",
+        ddiff = DeepDiff(t1, t2, significant_digits=3, number_format_notation="e",
                          number_to_string_func=custom_number_to_string)
 
         assert {} == ddiff