total_ordering now only overrides abtract methods defined in supercla…

…sses
python · gvanrossum · Oct 6, 2020 · Oct 1, 2020 · Oct 1, 2020 · Oct 1, 2020
commit 74473c83f6619b3da7fc984b63d04d0a07020c09
diff --git a/Lib/functools.py b/Lib/functools.py
@@ -187,20 +187,26 @@ def _lt_from_ge(self, other, NotImplemented=NotImplemented):
 
 def total_ordering(cls):
     """Class decorator that fills in missing ordering methods"""
-    # Find user-defined comparisons (not those inherited from object or abstract).
-    roots = {op for op in _convert
-             if (root := getattr(cls, op, None)) is not getattr(object, op, None)
-             and not getattr(root, '__isabstractmethod__', False)}
+    # Find user-defined comparisons (not those inherited from object or
+    # abstract).
+    def is_root(op):
+        root = getattr(cls, op, None)
+        if root is getattr(object, op, None):
+            return False
+        if getattr(root, '__isabstractmethod__', False):
+            # We only accept a root if it defined in the class itself.
+            return op in cls.__dict__
+        return True
+
+    roots = {op for op in _convert if is_root(op)}
     if not roots:
         raise ValueError('must define at least one ordering operation: < > <= >=')
     root = max(roots)       # prefer __lt__ to __le__ to __gt__ to __ge__
     for opname, opfunc in _convert[root]:
         if opname not in roots:
             opfunc.__name__ = opname
             setattr(cls, opname, opfunc)
-    # update the abstract methods of the class, if it is abstract
-    if isinstance(cls, ABCMeta):
-        update_abstractmethods(cls)
+    update_abstractmethods(cls)
     return cls
 
 

diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py
@@ -1158,16 +1158,38 @@ def test_pickle(self):
                     method_copy = pickle.loads(pickle.dumps(method, proto))
                     self.assertIs(method_copy, method)
 
+    def test_abc_forward(self):
+        @functools.total_ordering
+        class A(abc.ABC):
+            @abc.abstractmethod
+            def __lt__(self, other):
+                pass
+
+        self.assertLess({'__lt__', '__le__', '__gt__', '__ge__'}, A.__dict__.keys())
+        self.assertTrue(inspect.isabstract(A))
+        self.assertEqual(A.__abstractmethods__, {'__lt__'})
+
+        class Inf(A):
+            def __lt__(self, other):
+                return False
+
+        self.assertFalse(inspect.isabstract(Inf))
+        self.assertTrue(Inf().__gt__(None))
+
     def test_abc_impl(self):
         class A(abc.ABC):
             @abc.abstractmethod
             def __gt__(self, other):
                 pass
 
+            @abc.abstractmethod
+            def __lt__(self, other):
+                pass
+
+        @functools.total_ordering
         class B(A):
             def __lt__(self, other):
                 return True
-        B = functools.total_ordering(B)
         B()
         self.assertFalse(inspect.isabstract(B))