Merge pull request #588 from akshat62/feature/add-fraction-numeric-support

Add fractions.Fraction as a recognized numeric type

Author: seperman

deepdiff/helper.py

@@ -13,6 +13,7 @@
 from collections.abc import Mapping, Sequence, Generator
 from ast import literal_eval
 from decimal import Decimal, localcontext, InvalidOperation as InvalidDecimalOperation
+from fractions import Fraction
 from itertools import repeat
 from orderly_set import StableSetEq as SetOrderedBase  # median: 1.0867 s for cache test, 5.63s for all tests
 from threading import Timer
@@ -187,14 +188,14 @@ def get_semvar_as_integer(version: str) -> int:
 unicode_type = str
 bytes_type = bytes
 only_complex_number: Tuple[Type[Any], ...] = (complex,) + numpy_complex_numbers
-only_numbers: Tuple[Type[Any], ...] = (int, float, complex, Decimal) + numpy_numbers
+only_numbers: Tuple[Type[Any], ...] = (int, float, complex, Decimal, Fraction) + numpy_numbers
 datetimes: Tuple[Type[Any], ...] = (datetime.datetime, datetime.date, datetime.timedelta, datetime.time, np_datetime64)
 ipranges: Tuple[Type[Any], ...] = (ipaddress.IPv4Interface, ipaddress.IPv6Interface, ipaddress.IPv4Network, ipaddress.IPv6Network, ipaddress.IPv4Address, ipaddress.IPv6Address)
 uuids: Tuple[Type[uuid.UUID]] = (uuid.UUID, )
 times: Tuple[Type[Any], ...] = (datetime.datetime, datetime.time, np_datetime64)
 numbers: Tuple[Type[Any], ...] = only_numbers + datetimes
 # Type alias for use in type annotations
-NumberType = Union[int, float, complex, Decimal, datetime.datetime, datetime.date, datetime.timedelta, datetime.time, Any]
+NumberType = Union[int, float, complex, Decimal, Fraction, datetime.datetime, datetime.date, datetime.timedelta, datetime.time, Any]
 booleans: Tuple[Type[bool], Type[Any]] = (bool, np_bool_)
 
 basic_types: Tuple[Type[Any], ...] = strings + numbers + uuids + booleans + (type(None), )
@@ -433,6 +434,11 @@ def number_to_string(number: Any, significant_digits: int, number_format_notatio
                 # For example '999.99999999' will become '1000.000000' after quantize
                 ctx.prec += 1
                 number = number.quantize(Decimal('0.' + '0' * significant_digits))
+    elif isinstance(number, Fraction):
+        # Convert Fraction to float so that string formatting works on Python < 3.12
+        number = round(float(number), significant_digits)
+        if significant_digits == 0:
+            number = int(number)
     elif isinstance(number, only_complex_number):  # type: ignore
         # Case for complex numbers.
         number = number.__class__(

deepdiff/serialization.py

@@ -11,6 +11,7 @@
 import decimal  # NOQA
 import orderly_set  # NOQA
 import collections  # NOQA
+import fractions
 import ipaddress
 import base64
 from copy import deepcopy, copy
@@ -80,6 +81,7 @@ class UnsupportedFormatErr(TypeError):
     'datetime.time',
     'datetime.timedelta',
     'decimal.Decimal',
+    'fractions.Fraction',
     'uuid.UUID',
     'orderly_set.sets.OrderedSet',
     'orderly_set.sets.OrderlySet',
@@ -646,6 +648,13 @@ def _serialize_decimal(value):
         return float(value)
 
 
+def _serialize_fraction(value):
+    if value.denominator == 1:
+        return value.numerator
+    else:
+        return float(value)
+
+
 def _serialize_tuple(value):
     if hasattr(value, '_asdict'):  # namedtuple
         return value._asdict()
@@ -666,6 +675,7 @@ def _serialize_bytes(value):
 
 JSON_CONVERTOR = {
     decimal.Decimal: _serialize_decimal,
+    fractions.Fraction: _serialize_fraction,
     SetOrdered: list,
     orderly_set.StableSetEq: list,
     set: list,

docs/ignore_types_or_values.rst

@@ -65,18 +65,30 @@ Ignore Numeric Type Changes
 ignore_numeric_type_changes: Boolean, default = False
     Whether to ignore numeric type changes or not. For example 10 vs. 10.0 are considered the same if ignore_numeric_type_changes is set to True.
 
-Example
+Example with Decimal
     >>> from decimal import Decimal
     >>> from deepdiff import DeepDiff
-    >>> 
+    >>>
     >>> t1 = Decimal('10.01')
     >>> t2 = 10.01
-    >>> 
+    >>>
     >>> DeepDiff(t1, t2)
     {'type_changes': {'root': {'old_type': <class 'decimal.Decimal'>, 'new_type': <class 'float'>, 'old_value': Decimal('10.01'), 'new_value': 10.01}}}
     >>> DeepDiff(t1, t2, ignore_numeric_type_changes=True)
     {}
 
+Example with Fraction
+    >>> from fractions import Fraction
+    >>> from deepdiff import DeepDiff
+    >>>
+    >>> t1 = Fraction(1, 2)
+    >>> t2 = 0.5
+    >>>
+    >>> DeepDiff(t1, t2)
+    {'type_changes': {'root': {'old_type': <class 'fractions.Fraction'>, 'new_type': <class 'float'>, 'old_value': Fraction(1, 2), 'new_value': 0.5}}}
+    >>> DeepDiff(t1, t2, ignore_numeric_type_changes=True)
+    {}
+
 Note that this parameter only works for comparing numbers with numbers. If you compare a number to a string value of the number, this parameter does not solver your problem:
 
 Example:

docs/numbers.rst

@@ -41,6 +41,15 @@ Approximate decimals comparison (Significant digits after the point):
     >>> DeepDiff(t1, t2, significant_digits=1)
     {'values_changed': {'root': {'new_value': Decimal('1.57'), 'old_value': Decimal('1.52')}}}
 
+Approximate fractions comparison (Significant digits after the point):
+    >>> from fractions import Fraction
+    >>> t1 = Fraction(22, 7)   # 3.142857...
+    >>> t2 = Fraction(355, 113)  # 3.141592...
+    >>> DeepDiff(t1, t2, significant_digits=2)
+    {}
+    >>> DeepDiff(t1, t2, significant_digits=3)
+    {'values_changed': {'root': {'new_value': Fraction(355, 113), 'old_value': Fraction(22, 7)}}}
+
 Approximate float comparison (Significant digits after the point):
     >>> t1 = [ 1.1129, 1.3359 ]
     >>> t2 = [ 1.113, 1.3362 ]
@@ -131,13 +140,20 @@ math_epsilon: Decimal, default = None
 
     To check against that the math core module provides the valuable isclose() function. It evaluates the being close of two numbers to each other, with reference to an epsilon (abs_tol). This is superior to the format function, as it evaluates the mathematical representation and not the string representation.
 
-Example:
+Example with Decimal:
     >>> from decimal import Decimal
     >>> d1 = {"a": Decimal("7.175")}
     >>> d2 = {"a": Decimal("7.174")}
     >>> DeepDiff(d1, d2, math_epsilon=0.01)
     {}
 
+Example with Fraction:
+    >>> from fractions import Fraction
+    >>> d1 = {"a": Fraction(7175, 1000)}
+    >>> d2 = {"a": Fraction(7174, 1000)}
+    >>> DeepDiff(d1, d2, math_epsilon=0.01)
+    {}
+
 .. note::
     math_epsilon cannot currently handle the hashing of values, which is done when :ref:`ignore_order_label` is True.