bpo-41905: added abc.update_abstractmethods

Doc/library/abc.rst

@@ -174,10 +174,11 @@ The :mod:`abc` module also provides the following decorator:
    to declare abstract methods for properties and descriptors.
 
    Dynamically adding abstract methods to a class, or attempting to modify the
-   abstraction status of a method or class once it is created, are not
-   supported.  The :func:`abstractmethod` only affects subclasses derived using
-   regular inheritance; "virtual subclasses" registered with the ABC's
-   :meth:`register` method are not affected.
+   abstraction status of a method or class once it is created, are only
+   supported using the :func:`update_abstractmethods` function.  The
+   :func:`abstractmethod` only affects subclasses derived using regular
+   inheritance; "virtual subclasses" registered with the ABC's :meth:`register`
+   method are not affected.
 
    When :func:`abstractmethod` is applied in combination with other method
    descriptors, it should be applied as the innermost decorator, as shown in
@@ -235,7 +236,6 @@ The :mod:`abc` module also provides the following decorator:
       super-call in a framework that uses cooperative
       multiple-inheritance.
 
-
 The :mod:`abc` module also supports the following legacy decorators:
 
 .. decorator:: abstractclassmethod
@@ -335,6 +335,19 @@ The :mod:`abc` module also provides the following functions:
 
    .. versionadded:: 3.4
 
+.. function:: update_abstractmethods(cls)
+   A function to recalculate an abstract class's abstraction status. This
+   function should be called if a class's abstract methods have been
+   implemented or changed after it was created. Usually, this function should
+   be called from within a class decorator.
+
+   Returns *cls*, to allow usage as a class decorator.
+
+   If *cls* has any subclasses, raises a :exc:`RuntimeError`.
+
+   If *cls* is not an instance of ABCMeta, raises a :exc:`TypeError`.
+
+   .. versionadded:: 3.10
 
 .. rubric:: Footnotes
 

Lib/abc.py

@@ -121,6 +121,48 @@ def _abc_caches_clear(cls):
             """Clear the caches (for debugging or testing)."""
             _reset_caches(cls)
 
+def update_abstractmethods(cls):
+    """Repopulate the abstract methods of an abstract class, or a subclass of
+    an abstract class.
+
+    If a class has had one of its abstract methods implemented after the
+    class was created, the method will not be considered implemented until
+    this function is called. Alternatively, if a new abstract method has been
+    added to the class, it will only be considered an abstract method of the
+    class after this function is called.
+
+    This function should be called before any use is made of the class,
+    usually in class decorators that add methods to the subject class.
+
+    Returns cls, to allow usage as a class decorator.
+
+    If cls is has any subclasses, raises a RuntimeError.
+
+    If cls is not an instance of ABCMeta, raises a TypeError.
+    """
+    if not hasattr(cls, '__abstractmethods__'):
+        # We check for __abstractmethods__ here because cls might by a C
+        # implementation or a python implementation (especially during
+        # testing), and we want to handle both cases.
+        raise TypeError('cls must be an abstract class or subclass of an abstract'
+                        ' class')
+    if cls.__subclasses__():
+        raise RuntimeError("cannot update abstract methods of class after"
+                           " subclassing")
+
+    abstracts = set()
+    # Check the existing abstract methods, keep only the ones that are
+    # still abstract.
+    for name in cls.__abstractmethods__:
+        value = getattr(cls, name, None)
+        if getattr(value, "__isabstractmethod__", False):
+            abstracts.add(name)
+    # Also add any other newly added abstract methods.
+    for name, value in cls.__dict__.items():
+        if getattr(value, "__isabstractmethod__", False):
+            abstracts.add(name)
+    cls.__abstractmethods__ = frozenset(abstracts)
+    return cls
 
 class ABC(metaclass=ABCMeta):
     """Helper class that provides a standard way to create an ABC using

Lib/dataclasses.py

@@ -6,6 +6,7 @@
 import keyword
 import builtins
 import functools
+import abc
 import _thread
 from types import GenericAlias
 
@@ -992,6 +993,10 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen):
         cls.__doc__ = (cls.__name__ +
                        str(inspect.signature(cls)).replace(' -> None', ''))
 
+    # Update the abstract methods of the class, if it is abstract.
+    if isinstance(cls, abc.ABCMeta):
+        abc.update_abstractmethods(cls)
+
     return cls
 
 

Lib/functools.py

@@ -14,7 +14,7 @@
            'partial', 'partialmethod', 'singledispatch', 'singledispatchmethod',
            'cached_property']
 
-from abc import get_cache_token
+from abc import ABCMeta, get_cache_token, update_abstractmethods
 from collections import namedtuple
 # import types, weakref  # Deferred to single_dispatch()
 from reprlib import recursive_repr
@@ -187,15 +187,20 @@ 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).
-    roots = {op for op in _convert if getattr(cls, op, None) is not getattr(object, op, None)}
+    # Find user-defined comparisons (not those inherited from object or abstract).
+    roots = {op for op in _convert
+             if getattr(cls, op, None) is not getattr(object, op, None)
+             and not getattr(getattr(cls, op, None), '__isabstractmethod__', False)}
     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)
     return cls
 
 

Lib/test/test_abc.py

@@ -488,6 +488,87 @@ class C(with_metaclass(abc_ABCMeta, A, B)):
                 pass
             self.assertEqual(C.__class__, abc_ABCMeta)
 
+        def test_update_del(self):
+            class A(metaclass=abc_ABCMeta):
+                @abc.abstractmethod
+                def foo(self):
+                    pass
+
+            del A.foo
+            self.assertEqual(A.__abstractmethods__, {'foo'})
+            self.assertFalse(hasattr(A, 'foo'))
+
+            abc.update_abstractmethods(A)
+
+            self.assertEqual(A.__abstractmethods__, set())
+            A()
+
+
+        def test_update_new_abstractmethods(self):
+            class A(metaclass=abc_ABCMeta):
+                @abc.abstractmethod
+                def bar(self):
+                    pass
+
+            @abc.abstractmethod
+            def updated_foo(self):
+                pass
+
+            A.foo = updated_foo
+            abc.update_abstractmethods(A)
+            msg = "class A with abstract methods bar, foo"
+            self.assertEqual(A.__abstractmethods__, {'foo', 'bar'})
+            self.assertRaisesRegex(TypeError, msg, A)
+
+        def test_update_implementation(self):
+            class A(metaclass=abc_ABCMeta):
+                @abc.abstractmethod
+                def foo(self):
+                    pass
+
+            class B(A):
+                pass
+
+            msg = "class B with abstract method foo"
+            self.assertRaisesRegex(TypeError, msg, B)
+            self.assertEqual(B.__abstractmethods__, {'foo'})
+
+            B.foo = lambda self: None
+
+            abc.update_abstractmethods(B)
+
+            B()
+            self.assertEqual(B.__abstractmethods__, set())
+
+        def test_update_as_decorator(self):
+            class A(metaclass=abc_ABCMeta):
+                @abc.abstractmethod
+                def foo(self):
+                    pass
+
+            def class_decorator(cls):
+                cls.foo = lambda self: None
+                return cls
+
+            @abc.update_abstractmethods
+            @class_decorator
+            class B(A):
+                pass
+
+            B()
+            self.assertEqual(B.__abstractmethods__, set())
+
+        def test_update_non_abc(self):
+            class A:
+                pass
+
+            @abc.abstractmethod
+            def updated_foo(self):
+                pass
+
+            A.foo = updated_foo
+            self.assertRaises(TypeError, abc.update_abstractmethods, A)
+
 
     class TestABCWithInitSubclass(unittest.TestCase):
         def test_works_with_init_subclass(self):

Lib/test/test_dataclasses.py

@@ -4,6 +4,7 @@
 
 from dataclasses import *
 
+import abc
 import pickle
 import inspect
 import builtins
@@ -3332,6 +3333,42 @@ class C:
 
     ##     replace(c, x=5)
 
+class TestAbstract(unittest.TestCase):
+    def test_abc_implementation(self):
+        class Ordered(abc.ABC):
+            @abc.abstractmethod
+            def __lt__(self, other):
+                pass
+
+            @abc.abstractmethod
+            def __le__(self, other):
+                pass
+
+        @dataclass(order=True)
+        class Date(Ordered):
+            year: int
+            month: 'Month'
+            day: 'int'
+
+        self.assertFalse(inspect.isabstract(Date))
+        self.assertGreater(Date(2020,12,25), Date(2020,8,31))
+
+    def test_maintain_abc(self):
+        class A(abc.ABC):
+            @abc.abstractmethod
+            def foo(self):
+                pass
+
+        @dataclass
+        class Date(A):
+            year: int
+            month: 'Month'
+            day: 'int'
+
+        self.assertTrue(inspect.isabstract(Date))
+        msg = 'class Date with abstract method foo'
+        self.assertRaisesRegex(TypeError, msg, Date)
+
 
 if __name__ == '__main__':
     unittest.main()

Lib/test/test_functools.py

@@ -3,6 +3,7 @@
 import collections
 import collections.abc
 import copy
+import inspect
 from itertools import permutations
 import pickle
 from random import choice
@@ -1157,6 +1158,19 @@ def test_pickle(self):
                     method_copy = pickle.loads(pickle.dumps(method, proto))
                     self.assertIs(method_copy, method)
 
+    def test_abc_impl(self):
+        class A(abc.ABC):
+            @abc.abstractmethod
+            def __gt__(self, other):
+                pass
+
+        class B(A):
+            def __lt__(self, other):
+                return True
+        B = functools.total_ordering(B)
+        B()
+        self.assertFalse(inspect.isabstract(B))
+
 @functools.total_ordering
 class Orderable_LT:
     def __init__(self, value):

Misc/NEWS.d/next/Library/2020-10-01-21-11-03.bpo-41905._JpjR4.rst

@@ -0,0 +1 @@
+A new function in abc: *update_abstractmethods* to re-calculate an abstract class's abstract status. In addition, *dataclass* and *total_ordering* have been changed to call this function. Finally, *total_ordering* was patched so that it would override abstract methods.