python
diff --git a/‎Doc/library/abc.rst‎
Lines changed: 8 additions & 2 deletions b/‎Doc/library/abc.rst‎
Lines changed: 8 additions & 2 deletions
diff --git a/‎Lib/abc.py‎
Lines changed: 1 addition & 8 deletions b/‎Lib/abc.py‎
Lines changed: 1 addition & 8 deletions
diff --git a/‎Lib/test/test_abc.py‎
Lines changed: 24 additions & 0 deletions b/‎Lib/test/test_abc.py‎
Lines changed: 24 additions & 0 deletions
@@ -343,10 +343,16 @@ The :mod:`abc` module also provides the following functions:
 
    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, does nothing.
 
+   .. note::
+
+      Since it is meant to be called before the class is used by anywhere but
+      in the decorator that called it, this function assumes that *cls* has no
+      subclasses. This means that if the decorator itself creates subclasses
+      to *cls*, it must also call *update_abstractmethods* on each of them.
+
+
    .. versionadded:: 3.10
 
 .. rubric:: Footnotes
 
@@ -122,8 +122,7 @@ def _abc_caches_clear(cls):
             _reset_caches(cls)
 
 def update_abstractmethods(cls):
-    """Repopulate the abstract methods of an abstract class, or a subclass of
-    an abstract class.
+    """Recalculate the set of abstract methods 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
@@ -136,8 +135,6 @@ class after this function is called.
 
     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, does nothing.
     """
     if not hasattr(cls, '__abstractmethods__'):
@@ -146,10 +143,6 @@ class after this function is called.
         # testing), and we want to handle both cases.
         return cls
 
-    if cls.__subclasses__():
-        raise RuntimeError("cannot update abstract methods of class after"
-                           " subclassing")
-
     abstracts = set()
     # Check the existing abstract methods of the parents, keep only the ones
     # that are not implemented.
 
@@ -612,6 +612,30 @@ def foo(self):
             msg = "class C with abstract method foo"
             self.assertRaisesRegex(TypeError, msg, C)
 
+        def test_update_multi_inheritance(self):
+            class A(metaclass=abc_ABCMeta):
+                @abc.abstractmethod
+                def foo(self):
+                    pass
+
+            class B(metaclass=abc_ABCMeta):
+                def foo(self):
+                    pass
+
+            class C(B, A):
+                @abc.abstractmethod
+                def foo(self):
+                    pass
+
+            self.assertEqual(C.__abstractmethods__, {'foo'})
+
+            del C.foo
+
+            abc.update_abstractmethods(C)
+
+            self.assertEqual(C.__abstractmethods__, set())
+
+            C()
 
 
     class TestABCWithInitSubclass(unittest.TestCase):