python · dolfinus · Mar 30, 2025 · Mar 31, 2025 · Mar 31, 2025 · Mar 31, 2025
diff --git a/Lib/_py_abc.py b/Lib/_py_abc.py
@@ -49,6 +49,7 @@ def __new__(mcls, name, bases, namespace, /, **kwargs):
         cls._abc_cache = WeakSet()
         cls._abc_negative_cache = WeakSet()
         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
+        cls._abc_issubclasscheck_recursive = False
         return cls
 
     def register(cls, subclass):
@@ -66,7 +67,8 @@ def register(cls, subclass):
             # This would create a cycle, which is bad for the algorithm below
             raise RuntimeError("Refusing to create an inheritance cycle")
         cls._abc_registry.add(subclass)
-        ABCMeta._abc_invalidation_counter += 1  # Invalidate negative cache
+        # Invalidate negative cache
+        ABCMeta._abc_invalidation_counter += 1
         return subclass
 
     def _dump_registry(cls, file=None):
@@ -137,11 +139,29 @@ def __subclasscheck__(cls, subclass):
             if issubclass(subclass, rcls):
                 cls._abc_cache.add(subclass)
                 return True
+
         # Check if it's a subclass of a subclass (recursive)
         for scls in cls.__subclasses__():
-            if issubclass(subclass, scls):
-                cls._abc_cache.add(subclass)
+            # If inside recursive issubclass check, avoid adding classes to any cache because this
+            # may drastically increase memory usage.
+            # Unfortunately, issubclass/__subclasscheck__ don't accept third argument with context,
+            # so using global context within ABCMeta.
+            # This is done only on first method call, others will use cached result.
+            scls_is_abc = hasattr(scls, "_abc_issubclasscheck_recursive")
+            if scls_is_abc:
+                scls._abc_issubclasscheck_recursive = True
+
+            try:
+                result = issubclass(subclass, scls)
+            finally:
+                if scls_is_abc:
+                    scls._abc_issubclasscheck_recursive = False
+
+            if result:
+                if not cls._abc_issubclasscheck_recursive:
+                    cls._abc_cache.add(subclass)
                 return True
-        # No dice; update negative cache
-        cls._abc_negative_cache.add(subclass)
+
+        if not cls._abc_issubclasscheck_recursive:
+            cls._abc_negative_cache.add(subclass)
         return False
diff --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py
@@ -270,29 +270,100 @@ def x(self):
             class C(metaclass=meta):
                 pass
 
+        def test_isinstance_direct_inheritance(self):
+            class A(metaclass=abc_ABCMeta):
+                pass
+            class B(A):
+                pass
+            class C(A):
+                pass
+            a = A()
+            b = B()
+            c = C()
+            # trigger caching
+            for _ in range(2):
+                self.assertIsInstance(a, A)
+                self.assertIsInstance(a, (A,))
+                self.assertNotIsInstance(a, B)
+                self.assertNotIsInstance(a, (B,))
+                self.assertNotIsInstance(a, C)
+                self.assertNotIsInstance(a, (C,))
+
+                self.assertIsInstance(b, B)
+                self.assertIsInstance(b, (B,))
+                self.assertIsInstance(b, A)
+                self.assertIsInstance(b, (A,))
+                self.assertNotIsInstance(b, C)
+                self.assertNotIsInstance(b, (C,))
+
+                self.assertIsInstance(c, C)
+                self.assertIsInstance(c, (C,))
+                self.assertIsInstance(c, A)
+                self.assertIsInstance(c, (A,))
+                self.assertNotIsInstance(c, B)
+                self.assertNotIsInstance(c, (B,))
+
+                self.assertIsSubclass(B, A)
+                self.assertIsSubclass(B, (A,))
+                self.assertIsSubclass(C, A)
+                self.assertIsSubclass(C, (A,))
+                self.assertNotIsSubclass(B, C)
+                self.assertNotIsSubclass(B, (C,))
+                self.assertNotIsSubclass(C, B)
+                self.assertNotIsSubclass(C, (B,))
+                self.assertNotIsSubclass(A, B)
+                self.assertNotIsSubclass(A, (B,))
+                self.assertNotIsSubclass(A, C)
+                self.assertNotIsSubclass(A, (C,))
+
         def test_registration_basics(self):
             class A(metaclass=abc_ABCMeta):
                 pass
             class B(object):
                 pass
+            a = A()
             b = B()
-            self.assertNotIsSubclass(B, A)
-            self.assertNotIsSubclass(B, (A,))
-            self.assertNotIsInstance(b, A)
-            self.assertNotIsInstance(b, (A,))
+
+            # trigger caching
+            for _ in range(2):
+                self.assertNotIsSubclass(B, A)
+                self.assertNotIsSubclass(B, (A,))
+                self.assertNotIsInstance(b, A)
+                self.assertNotIsInstance(b, (A,))
+
+                self.assertNotIsSubclass(A, B)
+                self.assertNotIsSubclass(A, (B,))
+                self.assertNotIsInstance(a, B)
+                self.assertNotIsInstance(a, (B,))
+
             B1 = A.register(B)
-            self.assertIsSubclass(B, A)
-            self.assertIsSubclass(B, (A,))
-            self.assertIsInstance(b, A)
-            self.assertIsInstance(b, (A,))
-            self.assertIs(B1, B)
+            # trigger caching
+            for _ in range(2):
+                self.assertIsSubclass(B, A)
+                self.assertIsSubclass(B, (A,))
+                self.assertIsInstance(b, A)
+                self.assertIsInstance(b, (A,))
+                self.assertIs(B1, B)
+
+                self.assertNotIsSubclass(A, B)
+                self.assertNotIsSubclass(A, (B,))
+                self.assertNotIsInstance(a, B)
+                self.assertNotIsInstance(a, (B,))
+
             class C(B):
                 pass
             c = C()
-            self.assertIsSubclass(C, A)
-            self.assertIsSubclass(C, (A,))
-            self.assertIsInstance(c, A)
-            self.assertIsInstance(c, (A,))
+            # trigger caching
+            for _ in range(2):
+                self.assertIsSubclass(C, A)
+                self.assertIsSubclass(C, (A,))
+                self.assertIsInstance(c, A)
+                self.assertIsInstance(c, (A,))
+
+                self.assertNotIsSubclass(A, C)
+                self.assertNotIsSubclass(A, (C,))
+                self.assertNotIsInstance(a, C)
+                self.assertNotIsInstance(a, (C,))
 
         def test_register_as_class_deco(self):
             class A(metaclass=abc_ABCMeta):
@@ -377,39 +448,73 @@ class A(metaclass=abc_ABCMeta):
                 pass
             self.assertIsSubclass(A, A)
             self.assertIsSubclass(A, (A,))
+
             class B(metaclass=abc_ABCMeta):
                 pass
             self.assertNotIsSubclass(A, B)
             self.assertNotIsSubclass(A, (B,))
             self.assertNotIsSubclass(B, A)
             self.assertNotIsSubclass(B, (A,))
+
             class C(metaclass=abc_ABCMeta):
                 pass
             A.register(B)
             class B1(B):
                 pass
-            self.assertIsSubclass(B1, A)
-            self.assertIsSubclass(B1, (A,))
+            # trigger caching
+            for _ in range(2):
+                self.assertIsSubclass(B1, A)
+                self.assertIsSubclass(B1, (A,))
+
             class C1(C):
                 pass
             B1.register(C1)
-            self.assertNotIsSubclass(C, B)
-            self.assertNotIsSubclass(C, (B,))
-            self.assertNotIsSubclass(C, B1)
-            self.assertNotIsSubclass(C, (B1,))
-            self.assertIsSubclass(C1, A)
-            self.assertIsSubclass(C1, (A,))
-            self.assertIsSubclass(C1, B)
-            self.assertIsSubclass(C1, (B,))
-            self.assertIsSubclass(C1, B1)
-            self.assertIsSubclass(C1, (B1,))
+            # trigger caching
+            for _ in range(2):
+                self.assertNotIsSubclass(C, B)
+                self.assertNotIsSubclass(C, (B,))
+                self.assertNotIsSubclass(C, B1)
+                self.assertNotIsSubclass(C, (B1,))
+                self.assertIsSubclass(C1, A)
+                self.assertIsSubclass(C1, (A,))
+                self.assertIsSubclass(C1, B)
+                self.assertIsSubclass(C1, (B,))
+                self.assertIsSubclass(C1, B1)
+                self.assertIsSubclass(C1, (B1,))
+
             C1.register(int)
             class MyInt(int):
                 pass
-            self.assertIsSubclass(MyInt, A)
-            self.assertIsSubclass(MyInt, (A,))
-            self.assertIsInstance(42, A)
-            self.assertIsInstance(42, (A,))
+            # trigger caching
+            for _ in range(2):
+                self.assertIsSubclass(MyInt, A)
+                self.assertIsSubclass(MyInt, (A,))
+                self.assertIsInstance(42, A)
+                self.assertIsInstance(42, (A,))
+
+        def test_custom_subclasses(self):
+            class A: pass
+            class B: pass
+
+            class Parent1(metaclass=abc_ABCMeta):
+                @classmethod
+                def __subclasses__(cls):
+                    return [A]
+
+            class Parent2(metaclass=abc_ABCMeta):
+                __subclasses__ = lambda: [A]
+
+            # trigger caching
+            for _ in range(2):
+                self.assertIsInstance(A(), Parent1)
+                self.assertIsSubclass(A, Parent1)
+                self.assertNotIsInstance(B(), Parent1)
+                self.assertNotIsSubclass(B, Parent1)
+
+                self.assertIsInstance(A(), Parent2)
+                self.assertIsSubclass(A, Parent2)
+                self.assertNotIsInstance(B(), Parent2)
+                self.assertNotIsSubclass(B, Parent2)
 
         def test_issubclass_bad_arguments(self):
             class A(metaclass=abc_ABCMeta):
@@ -522,7 +627,6 @@ def foo(self):
             self.assertEqual(A.__abstractmethods__, set())
             A()
 
-
         def test_update_new_abstractmethods(self):
             class A(metaclass=abc_ABCMeta):
                 @abc.abstractmethod

diff --git a/Lib/test/test_isinstance.py b/Lib/test/test_isinstance.py
@@ -351,6 +351,28 @@ class B:
         with support.infinite_recursion(25):
             self.assertRaises(RecursionError, issubclass, X(), int)
 
+    def test_custom_subclasses_are_ignored(self):
+        class A: pass
+        class B: pass
+
+        class Parent1:
+            @classmethod
+            def __subclasses__(cls):
+                return [A, B]
+
+        class Parent2:
+            __subclasses__ = lambda: [A, B]
+
+        self.assertNotIsInstance(A(), Parent1)
+        self.assertNotIsInstance(B(), Parent1)
+        self.assertNotIsSubclass(A, Parent1)
+        self.assertNotIsSubclass(B, Parent1)
+
+        self.assertNotIsInstance(A(), Parent2)
+        self.assertNotIsInstance(B(), Parent2)
+        self.assertNotIsSubclass(A, Parent2)
+        self.assertNotIsSubclass(B, Parent2)
+
 
 def blowstack(fxn, arg, compare_to):
     # Make sure that calling isinstance with a deeply nested tuple for its

diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2025-06-13-17-22-34.gh-issue-92810.Tb6x6C.rst b/Misc/NEWS.d/next/Core_and_Builtins/2025-06-13-17-22-34.gh-issue-92810.Tb6x6C.rst
@@ -0,0 +1,2 @@
+Reduce memory usage by :meth:`~type.__subclasscheck__`
+for :class:`abc.ABCMeta` and large class trees
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		Reduce memory usage by :meth:`~type.__subclasscheck__`
Copy link Member picnixz Aug 2, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others. Learn more. I think this can be also added in What's New with concrete numbers (I think we have an optimizations section). The NEWS entry should be in `Library` though as it doesn't affect the builtins themselves. Copy link Author dolfinus Aug 4, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others. Learn more. I think this can be also added in What's New Is there an example how this entry should be added? I'm new to CPython sources, and there can be some rules for this I'm not familiar with. Copy link Member picnixz Aug 4, 2025 • edited Loading Choose a reason for hiding this comment The reason will be displayed to describe this comment to others. Learn more. Yes: open Doc/whatsnew/3.15.rst, and check if we have an optimization section in the document. Then just write something like: Optimizations ============= abc --- * Reduce memory usage of `issubclass` checks for classes inheriting abstract classes. (Contributed by YOUR_NAME_OR_GITHUB_HANDLE in :gh:`92810`.) You can add some relevant numbers if you want. Copy link Author dolfinus Aug 4, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others. Learn more. This requires rebasing or merging the main branch. Which option is preferred? Copy link Member picnixz Aug 4, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others. Learn more. Just merge the main branch by hitting the "update" button and pull the remote changes (that way you can be sure that your local branch won't be desynced). We squash-merge commits at the end and we rewrite the commit message so it doesn't matter how messy your commit history is. It's better not to force-push because it breaks incremental GitHub reviews (there are only specific cases when you can force push but generally, we recommend avoiding force-pushing). Copy link Author dolfinus Aug 4, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others. Learn more. Added a What's New entry, but without any numbers, as they depend on the size of class tree
		for :class:`abc.ABCMeta` and large class trees
dolfinus marked this conversation as resolved. Show resolved Hide resolved