Prevent 'complex' handling in division methods.

See python/cpython#102842

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
 
+* Using ``complex`` numbers in division shows better tracebacks.
+  https://github.com/python/cpython/pull/102842
+
 
 1.18 (2024-04-03)
 -----------------

src/quicktions.pyx

@@ -897,35 +897,35 @@ cdef class Fraction:
 
     def __floordiv__(a, b):
         """a // b"""
-        return forward(a, b, _floordiv, _math_op_floordiv)
+        return forward(a, b, _floordiv, _math_op_floordiv, handle_complex=False)
 
     def __rfloordiv__(b, a):
         """a // b"""
-        return reverse(a, b, _floordiv, _math_op_floordiv)
+        return reverse(a, b, _floordiv, _math_op_floordiv, handle_complex=False)
 
     def __mod__(a, b):
         """a % b"""
-        return forward(a, b, _mod, _math_op_mod)
+        return forward(a, b, _mod, _math_op_mod, handle_complex=False)
 
     def __rmod__(b, a):
         """a % b"""
-        return reverse(a, b, _mod, _math_op_mod)
+        return reverse(a, b, _mod, _math_op_mod, handle_complex=False)
 
     def __divmod__(a, b):
         """divmod(self, other): The pair (self // other, self % other).
 
         Sometimes this can be computed faster than the pair of
         operations.
         """
-        return forward(a, b, _divmod, _math_op_divmod)
+        return forward(a, b, _divmod, _math_op_divmod, handle_complex=False)
 
     def __rdivmod__(b, a):
         """divmod(self, other): The pair (self // other, self % other).
 
         Sometimes this can be computed faster than the pair of
         operations.
         """
-        return reverse(a, b, _divmod, _math_op_divmod)
+        return reverse(a, b, _divmod, _math_op_divmod, handle_complex=False)
 
     def __pow__(a, b, x):
         """a ** b
@@ -1516,7 +1516,7 @@ cdef:
 ctypedef object (*math_func)(an, ad, bn, bd)
 
 
-cdef forward(a, b, math_func monomorphic_operator, pyoperator):
+cdef forward(a, b, math_func monomorphic_operator, pyoperator, handle_complex=True):
     an, ad = (<Fraction>a)._numerator, (<Fraction>a)._denominator
     if type(b) is Fraction:
         return monomorphic_operator(an, ad, (<Fraction>b)._numerator, (<Fraction>b)._denominator)
@@ -1526,21 +1526,21 @@ cdef forward(a, b, math_func monomorphic_operator, pyoperator):
         return monomorphic_operator(an, ad, b.numerator, b.denominator)
     elif isinstance(b, float):
         return pyoperator(_as_float(an, ad), b)
-    elif isinstance(b, complex):
+    elif handle_complex and isinstance(b, complex):
         return pyoperator(complex(a), b)
     else:
         return NotImplemented
 
 
-cdef reverse(a, b, math_func monomorphic_operator, pyoperator):
+cdef reverse(a, b, math_func monomorphic_operator, pyoperator, handle_complex=True):
     bn, bd = (<Fraction>b)._numerator, (<Fraction>b)._denominator
     if isinstance(a, (int, long)):
         return monomorphic_operator(a, 1, bn, bd)
     elif isinstance(a, Rational):
         return monomorphic_operator(a.numerator, a.denominator, bn, bd)
     elif isinstance(a, Real):
         return pyoperator(float(a), _as_float(bn, bd))
-    elif isinstance(a, Complex):
+    elif handle_complex and isinstance(a, Complex):
         return pyoperator(complex(a), complex(b))
     else:
         return NotImplemented

src/test_fractions.py

@@ -1535,6 +1535,33 @@ def test_float_format_testfile(self):
                     self.assertEqual(float(format(f, fmt2)), float(rhs))
                     self.assertEqual(float(format(-f, fmt2)), float('-' + rhs))
 
+    def test_complex_handling(self):
+        # See issue gh-102840 for more details.
+
+        a = F(1, 2)
+        b = 1j
+        message = "unsupported operand type(s) for %s: '%s' and '%s'"
+        # test forward
+        self.assertRaisesMessage(TypeError,
+                                 message % ("%", "quicktions.Fraction", "complex"),
+                                 operator.mod, a, b)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("//", "quicktions.Fraction", "complex"),
+                                 operator.floordiv, a, b)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("divmod()", "quicktions.Fraction", "complex"),
+                                 divmod, a, b)
+        # test reverse
+        self.assertRaisesMessage(TypeError,
+                                 message % ("%", "complex", "quicktions.Fraction"),
+                                 operator.mod, b, a)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("//", "complex", "quicktions.Fraction"),
+                                 operator.floordiv, b, a)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("divmod()", "complex", "quicktions.Fraction"),
+                                 divmod, b, a)
+
 
 class QuicktionsTest(unittest.TestCase):
     _pi = (