Add classmethod ".from_number()".

See python/cpython#121800

Author: scoder

CHANGES.rst

@@ -9,6 +9,9 @@ ChangeLog
 * Generally use ``.as_integer_ratio()`` in the constructor if available.
   https://github.com/python/cpython/pull/120271
 
+* Add a classmethod ``.from_number()`` that requires a number argument, not a string.
+  https://github.com/python/cpython/pull/121800
+
 * Mixed calculations with other ``Rational`` classes could return the wrong type.
   https://github.com/python/cpython/issues/119189
 

src/quicktions.pyx

@@ -482,7 +482,8 @@ cdef class Fraction:
                 return
 
             else:
-                raise TypeError("argument should be a string or a number")
+                raise TypeError("argument should be a string or a Rational "
+                                "instance or have the as_integer_ratio() method")
 
         elif type(numerator) is int is type(denominator):
             pass  # *very* normal case
@@ -526,6 +527,34 @@ cdef class Fraction:
         self._numerator = numerator
         self._denominator = denominator
 
+    @classmethod
+    def from_number(cls, number):
+        """Converts a finite real number to a rational number, exactly.
+
+        Beware that Fraction.from_number(0.3) != Fraction(3, 10).
+
+        """
+        if type(number) is int:
+            return _fraction_from_coprime_ints(number, 1, cls)
+
+        elif type(number) is Fraction:
+            return _fraction_from_coprime_ints((<Fraction> number)._numerator, (<Fraction> number)._denominator, cls)
+
+        elif isinstance(number, float):
+            n, d = number.as_integer_ratio()
+            return _fraction_from_coprime_ints(n, d, cls)
+
+        elif isinstance(number, Rational):
+            return _fraction_from_coprime_ints(number.numerator, number.denominator, cls)
+
+        elif not isinstance(number, type) and hasattr(number, 'as_integer_ratio'):
+            n, d = number.as_integer_ratio()
+            return _fraction_from_coprime_ints(n, d, cls)
+
+        else:
+            raise TypeError("argument should be a Rational instance or "
+                            "have the as_integer_ratio() method")
+
     @classmethod
     def from_float(cls, f):
         """Converts a finite float to a rational number, exactly.

src/test_fractions.py

@@ -392,6 +392,13 @@ def __repr__(self):
 class RectComplex(Rect, complex):
     pass
 
+class Ratio:
+    def __init__(self, ratio):
+        self._ratio = ratio
+    def as_integer_ratio(self):
+        return self._ratio
+
+
 class FractionTest(unittest.TestCase):
 
     def assertTypedEquals(self, expected, actual):
@@ -474,14 +481,9 @@ def testInitFromDecimal(self):
         self.assertRaises(OverflowError, F, Decimal('-inf'))
 
     def testInitFromIntegerRatio(self):
-        class Ratio:
-            def __init__(self, ratio):
-                self._ratio = ratio
-            def as_integer_ratio(self):
-                return self._ratio
-
         self.assertEqual((7, 3), _components(F(Ratio((7, 3)))))
-        errmsg = "argument should be a string or a number"
+        errmsg = (r"argument should be a string or a Rational instance or "
+                  r"have the as_integer_ratio\(\) method")
         # the type also has an "as_integer_ratio" attribute.
         self.assertRaisesRegex(TypeError, errmsg, F, Ratio)
         # bad ratio
@@ -507,6 +509,8 @@ class B(metaclass=M):
             pass
         self.assertRaisesRegex(TypeError, errmsg, F, B)
         self.assertRaisesRegex(TypeError, errmsg, F, B())
+        self.assertRaises(TypeError, F.from_number, B)
+        self.assertRaises(TypeError, F.from_number, B())
 
     def testFromString(self):
         self.assertEqual((5, 1), _components(F("5")))
@@ -746,6 +750,36 @@ def testFromDecimal(self):
             ValueError, "Cannot convert sNaN to Fraction.",
             F.from_decimal, Decimal("snan"))
 
+    def testFromNumber(self, cls=F):
+        def check(arg, numerator, denominator):
+            f = cls.from_number(arg)
+            self.assertIs(type(f), cls)
+            self.assertEqual(f.numerator, numerator)
+            self.assertEqual(f.denominator, denominator)
+
+        check(10, 10, 1)
+        check(2.5, 5, 2)
+        check(Decimal('2.5'), 5, 2)
+        check(F(22, 7), 22, 7)
+        check(DummyFraction(22, 7), 22, 7)
+        check(Rat(22, 7), 22, 7)
+        check(Ratio((22, 7)), 22, 7)
+        self.assertRaises(TypeError, cls.from_number, 3+4j)
+        self.assertRaises(TypeError, cls.from_number, '5/2')
+        self.assertRaises(TypeError, cls.from_number, [])
+        self.assertRaises(OverflowError, cls.from_number, float('inf'))
+        self.assertRaises(OverflowError, cls.from_number, Decimal('inf'))
+
+        # as_integer_ratio not defined in a class
+        class A:
+            pass
+        a = A()
+        a.as_integer_ratio = lambda: (9, 5)
+        check(a, 9, 5)
+
+    def testFromNumber_subclass(self):
+        self.testFromNumber(DummyFraction)
+
     def test_is_integer(self):
         self.assertTrue(F(1, 1).is_integer())
         self.assertTrue(F(-1, 1).is_integer())