bpo-37836: support .as_integer_ratio() in Fraction

Doc/library/fractions.rst

@@ -14,27 +14,25 @@
 The :mod:`fractions` module provides support for rational number arithmetic.
 
 
-A Fraction instance can be constructed from a pair of integers, from
-another rational number, or from a string.
+A Fraction instance can be constructed from a numerator and denominator
+or from a string.
 
 .. class:: Fraction(numerator=0, denominator=1)
-           Fraction(other_fraction)
-           Fraction(float)
-           Fraction(decimal)
            Fraction(string)
 
-   The first version requires that *numerator* and *denominator* are instances
-   of :class:`numbers.Rational` and returns a new :class:`Fraction` instance
-   with value ``numerator/denominator``. If *denominator* is :const:`0`, it
-   raises a :exc:`ZeroDivisionError`. The second version requires that
-   *other_fraction* is an instance of :class:`numbers.Rational` and returns a
-   :class:`Fraction` instance with the same value.  The next two versions accept
-   either a :class:`float` or a :class:`decimal.Decimal` instance, and return a
-   :class:`Fraction` instance with exactly the same value.  Note that due to the
-   usual issues with binary floating-point (see :ref:`tut-fp-issues`), the
-   argument to ``Fraction(1.1)`` is not exactly equal to 11/10, and so
+   In the first version, *numerator* and *denominator* must either have
+   an ``as_integer_ratio()`` method or be instances of
+   :class:`numbers.Rational`. This includes in particular :class:`int`,
+   :class:`Fraction`, :class:`float` and :class:`decimal.Decimal`.
+   It returns a new :class:`Fraction` instance with value
+   ``numerator/denominator``. If *denominator* is :const:`0`, it raises a
+   :exc:`ZeroDivisionError`.
+
+   Note that due to the usual issues with binary floating-point
+   (see :ref:`tut-fp-issues`), 1.1 is not exactly equal to 11/10, and so
    ``Fraction(1.1)`` does *not* return ``Fraction(11, 10)`` as one might expect.
    (But see the documentation for the :meth:`limit_denominator` method below.)
+
    The last version of the constructor expects a string or unicode instance.
    The usual form for this instance is::
 
@@ -69,6 +67,8 @@ another rational number, or from a string.
       Fraction(9, 4)
       >>> Fraction(1.1)
       Fraction(2476979795053773, 2251799813685248)
+      >>> Fraction(3.5, 2.5)
+      Fraction(7, 5)
       >>> from decimal import Decimal
       >>> Fraction(Decimal('1.1'))
       Fraction(11, 10)
@@ -82,7 +82,12 @@ another rational number, or from a string.
 
    .. versionchanged:: 3.2
       The :class:`Fraction` constructor now accepts :class:`float` and
-      :class:`decimal.Decimal` instances.
+      :class:`decimal.Decimal` instances as a single argument.
+
+   .. versionchanged:: 3.9
+      The :class:`Fraction` constructor now accepts any object with
+      ``as_integer_ratio()`` (in particular also :class:`float` and
+      :class:`decimal.Decimal` instances) as numerator or denominator.
 
 
    .. attribute:: numerator

Lib/fractions.py

@@ -57,25 +57,43 @@ def _gcd(a, b):
 """, re.VERBOSE | re.IGNORECASE)
 
 
+def _as_integer_ratio(obj):
+    """
+    Return a pair (numerator, denominator) if obj has an ``as_integer_ratio``
+    method or is an instance of ``numbers.Rational``. Return ``NotImplemented``
+    if neither works.
+    """
+    try:
+        f = obj.as_integer_ratio
+    except AttributeError:
+        if isinstance(obj, numbers.Rational):
+            return (obj.numerator, obj.denominator)
+    else:
+        return f()
+
+    return NotImplemented
+
+
 class Fraction(numbers.Rational):
     """This class implements rational numbers.
 
     In the two-argument form of the constructor, Fraction(8, 6) will
-    produce a rational number equivalent to 4/3. Both arguments must
-    be Rational. The numerator defaults to 0 and the denominator
-    defaults to 1 so that Fraction(3) == 3 and Fraction() == 0.
+    produce a rational number equivalent to 4/3. The numerator defaults
+    to 0 and the denominator defaults to 1 so that Fraction(3) == 3 and
+    Fraction() == 0. The numerator and denominator can be:
+
+      - objects with an ``as_integer_ratio()`` method (this includes
+        integers, Fractions, floats and Decimal instances)
 
-    Fractions can also be constructed from:
+      - other Rational instances
+
+    Fractions can also be constructed from a string (in this case, only
+    a single argument is allowed):
 
       - numeric strings similar to those accepted by the
         float constructor (for example, '-2.3' or '1e10')
 
       - strings of the form '123/456'
-
-      - float and Decimal instances
-
-      - other Rational instances (including integers)
-
     """
 
     __slots__ = ('_numerator', '_denominator')
@@ -115,23 +133,19 @@ def __new__(cls, numerator=0, denominator=None, *, _normalize=True):
         self = super(Fraction, cls).__new__(cls)
 
         if denominator is None:
+            # Fast path for Fraction(int)
             if type(numerator) is int:
                 self._numerator = numerator
                 self._denominator = 1
                 return self
-
-            elif isinstance(numerator, numbers.Rational):
-                self._numerator = numerator.numerator
-                self._denominator = numerator.denominator
-                return self
-
-            elif isinstance(numerator, (float, Decimal)):
-                # Exact conversion
-                self._numerator, self._denominator = numerator.as_integer_ratio()
-                return self
-
+            nd = _as_integer_ratio(numerator)
+            if nd is not NotImplemented:
+                numerator, denominator = nd
+                # Assume that result is already normalized
+                _normalize = False
+            # _as_integer_ratio() returned NotImplemented, so we
+            # failed unless we got a string
             elif isinstance(numerator, str):
-                # Handle construction from strings.
                 m = _RATIONAL_FORMAT.match(numerator)
                 if m is None:
                     raise ValueError('Invalid literal for Fraction: %r' %
@@ -158,21 +172,24 @@ def __new__(cls, numerator=0, denominator=None, *, _normalize=True):
                     numerator = -numerator
 
             else:
-                raise TypeError("argument should be a string "
-                                "or a Rational instance")
+                raise TypeError("argument should be a string, "
+                                "a Rational instance or have "
+                                "an as_integer_ratio() method")
 
         elif type(numerator) is int is type(denominator):
-            pass # *very* normal case
-
-        elif (isinstance(numerator, numbers.Rational) and
-            isinstance(denominator, numbers.Rational)):
-            numerator, denominator = (
-                numerator.numerator * denominator.denominator,
-                denominator.numerator * numerator.denominator
-                )
+            # Fast path for Fraction(int, int)
+            pass
         else:
-            raise TypeError("both arguments should be "
-                            "Rational instances")
+            x = _as_integer_ratio(numerator)
+            y = _as_integer_ratio(denominator)
+            if x is NotImplemented or y is NotImplemented:
+                raise TypeError("both arguments should be "
+                                "a Rational instance or have "
+                                "an as_integer_ratio() method")
+            num1, den1 = x
+            den2, num2 = y
+            numerator = num1 * num2
+            denominator = den1 * den2
 
         if denominator == 0:
             raise ZeroDivisionError('Fraction(%s, 0)' % numerator)

Lib/test/test_fractions.py

@@ -78,6 +78,15 @@ def __ge__(self, other):
     def __float__(self):
         assert False, "__float__ should not be invoked"
 
+
+class IntegerRatio:
+    def __init__(self, num, den):
+        self.integer_ratio = (num, den)
+
+    def as_integer_ratio(self):
+        return self.integer_ratio
+
+
 class DummyFraction(fractions.Fraction):
     """Dummy Fraction subclass for copy and deepcopy testing."""
 
@@ -155,11 +164,13 @@ def testInit(self):
         self.assertRaises(TypeError, F, "3/2", 3)
         self.assertRaises(TypeError, F, 3, 0j)
         self.assertRaises(TypeError, F, 3, 1j)
+        self.assertRaises(TypeError, F, 1j, 3)
         self.assertRaises(TypeError, F, 1, 2, 3)
 
     @requires_IEEE_754
     def testInitFromFloat(self):
         self.assertEqual((5, 2), _components(F(2.5)))
+        self.assertEqual((5, 7), _components(F(2.5, 3.5)))
         self.assertEqual((0, 1), _components(F(-0.0)))
         self.assertEqual((3602879701896397, 36028797018963968),
                          _components(F(0.1)))
@@ -171,6 +182,8 @@ def testInitFromFloat(self):
     def testInitFromDecimal(self):
         self.assertEqual((11, 10),
                          _components(F(Decimal('1.1'))))
+        self.assertEqual((11, 10),
+                         _components(F(Decimal('9.9'), Decimal(9))))
         self.assertEqual((7, 200),
                          _components(F(Decimal('3.5e-2'))))
         self.assertEqual((0, 1),
@@ -302,6 +315,14 @@ def testFromDecimal(self):
             ValueError, "cannot convert NaN to integer ratio",
             F.from_decimal, Decimal("snan"))
 
+    def testFromIntegerRatio(self):
+        a = IntegerRatio(-5, 4)
+        b = IntegerRatio(-5, 3)
+        self.assertEqual(F(a).as_integer_ratio(), (-5, 4))
+        self.assertEqual(F(a, b).as_integer_ratio(), (3, 4))
+        self.assertEqual(F(1, a).as_integer_ratio(), (-4, 5))
+        self.assertEqual(F(a, 5.0).as_integer_ratio(), (-1, 4))
+
     def test_as_integer_ratio(self):
         self.assertEqual(F(4, 6).as_integer_ratio(), (2, 3))
         self.assertEqual(F(-4, 6).as_integer_ratio(), (-2, 3))

Misc/NEWS.d/next/Library/2019-08-18-22-29-59.bpo-37836.BbvvFm.rst

@@ -0,0 +1,3 @@
+When constructing a :class:`fractions.Fraction`, the given numerator and
+denominator may now be any object with an ``as_integer_ratio`` method.
+This allows, for example, passing floats for both the numerator and denominator.