Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions Include/internal/pycore_global_objects_fini_generated.h

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

1 change: 1 addition & 0 deletions Include/internal/pycore_global_strings.h
Original file line number Diff line number Diff line change
Expand Up @@ -241,6 +241,7 @@ struct _Py_global_strings {
STRUCT_FOR_ID(__str__)
STRUCT_FOR_ID(__sub__)
STRUCT_FOR_ID(__subclasscheck__)
STRUCT_FOR_ID(__subclasses__)
STRUCT_FOR_ID(__subclasshook__)
STRUCT_FOR_ID(__truediv__)
STRUCT_FOR_ID(__trunc__)
Expand Down
1 change: 1 addition & 0 deletions Include/internal/pycore_runtime_init_generated.h

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

1 change: 1 addition & 0 deletions Include/internal/pycore_unicodeobject_generated.h

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

6 changes: 5 additions & 1 deletion Lib/abc.py
Original file line number Diff line number Diff line change
Expand Up @@ -105,7 +105,7 @@ def __init__(
try:
from _abc import (get_cache_token, _abc_init, _abc_register,
_abc_instancecheck, _abc_subclasscheck, _get_dump,
_reset_registry, _reset_caches)
_reset_registry, _reset_caches, _set_subclasscheck)
except ImportError:
from _py_abc import ABCMeta, get_cache_token
ABCMeta.__module__ = 'abc'
Expand Down Expand Up @@ -163,6 +163,10 @@ def _abc_caches_clear(cls):
"""Clear the caches (for debugging or testing)."""
_reset_caches(cls)

# Classes using the default __subclasscheck__ are checked
# directly by the C implementation.
_set_subclasscheck(ABCMeta.__subclasscheck__)


def update_abstractmethods(cls):
"""Recalculate the set of abstract methods of an abstract class.
Expand Down
138 changes: 138 additions & 0 deletions Lib/test/test_abc.py
Original file line number Diff line number Diff line change
Expand Up @@ -556,6 +556,144 @@ class C:
self.assertNotIsSubclass(C, A)
self.assertNotIsSubclass(C, (A,))

def test_subclasshook_of_subclass(self):
# The hook of a subclass of an ABC applies to the ABC too.
class A(metaclass=abc_ABCMeta):
pass
class B(A):
@classmethod
def __subclasshook__(cls, C):
if cls is B:
return 'foo' in C.__dict__
return NotImplemented
class C:
foo = 42
class D:
spam = 42
self.assertIsSubclass(C, A)
self.assertIsSubclass(C, B)
self.assertNotIsSubclass(D, A)
self.assertNotIsSubclass(D, B)
self.assertIsInstance(C(), A)
self.assertNotIsInstance(D(), A)

def test_subclasscheck_of_subclass_metaclass(self):
# A __subclasscheck__ override on the metaclass of a subclass
# is honoured when walking the subclass tree of an ABC.
class Meta(abc_ABCMeta):
def __subclasscheck__(cls, subclass):
if subclass is int:
return True
return super().__subclasscheck__(subclass)
class A(metaclass=abc_ABCMeta):
pass
class B(A, metaclass=Meta):
pass
self.assertIsSubclass(int, B)
self.assertIsSubclass(int, A)
self.assertNotIsSubclass(str, A)
self.assertIsInstance(1, A)
self.assertNotIsInstance('', A)

def test_subclasses_override_of_subclass(self):
# A __subclasses__ override in a subclass is honoured.
class Other:
pass
class A(metaclass=abc_ABCMeta):
pass
class B(A):
@classmethod
def __subclasses__(cls):
return [Other]
self.assertIsSubclass(Other, B)
self.assertIsSubclass(Other, A)
self.assertNotIsSubclass(int, A)

def test_registration_in_subclass_tree(self):
class A(metaclass=abc_ABCMeta):
pass
class B(A):
pass
class C(B):
pass
class D:
pass
class E(D):
pass
self.assertNotIsSubclass(E, A)
C.register(D)
self.assertIsSubclass(D, C)
self.assertIsSubclass(D, B)
self.assertIsSubclass(D, A)
self.assertIsSubclass(E, A)
self.assertIsInstance(E(), A)
self.assertNotIsSubclass(int, A)

def test_instancecheck_class_attribute(self):
class A(metaclass=abc_ABCMeta):
pass
class B(A):
pass
class ClassProperty:
@property
def __class__(self):
return B
class GetAttribute:
def __getattribute__(self, name):
if name == '__class__':
return B
return object.__getattribute__(self, name)
class ClassAttributeNotAType:
__class__ = 42
self.assertIsInstance(ClassProperty(), A)
self.assertIsInstance(GetAttribute(), A)
self.assertNotIsInstance(ClassProperty(), int)
with self.assertRaises(TypeError):
isinstance(ClassAttributeNotAType(), A)

def test_cache_with_transient_classes(self):
# Classes come and go, and their addresses get reused; the
# caches must never confuse a dead class with a new one.
import gc
class A(metaclass=abc_ABCMeta):
pass
for i in range(50):
class Sub(A):
pass
class NotSub:
pass
self.assertIsSubclass(Sub, A)
self.assertNotIsSubclass(NotSub, A)
self.assertIsInstance(Sub(), A)
self.assertNotIsInstance(NotSub(), A)
A.register(NotSub)
self.assertIsSubclass(NotSub, A)
del Sub, NotSub
gc.collect()

def test_negative_cache_not_populated_in_subclass_tree(self):
# gh-92810: checking a class against an ABC must not add it to
# the negative cache of every subclass of that ABC.
if abc_ABCMeta is not abc.ABCMeta:
self.skipTest('C implementation only')
try:
from _abc import _get_dump
except ImportError:
self.skipTest('C implementation only')
class A(metaclass=abc_ABCMeta):
pass
subclasses = [type(f'B{i}', (A,), {}) for i in range(10)]
class C:
pass
self.assertNotIsSubclass(C, A)
self.assertEqual(len(_get_dump(A)[2]), 1)
for B in subclasses:
self.assertEqual(_get_dump(B)[2], set())
# Results are cached at the top level only.
self.assertNotIsSubclass(C, A)
self.assertNotIsSubclass(C, subclasses[0])
self.assertEqual(len(_get_dump(subclasses[0])[2]), 1)

def test_all_new_methods_are_called(self):
class A(metaclass=abc_ABCMeta):
pass
Expand Down
103 changes: 103 additions & 0 deletions Lib/test/test_free_threading/test_abc.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,103 @@
import gc
import os
import threading
import unittest
from abc import ABC

from test.support import threading_helper


class TestABC(unittest.TestCase):

@threading_helper.reap_threads
@threading_helper.requires_working_threading()
def test_concurrent_checks(self):
# isinstance()/issubclass() from many threads while other threads
# register classes, clear the caches and create and destroy
# subclasses.
class A(ABC):
pass
class B(A):
pass
class C(B):
pass
class Registered:
pass
class Other:
pass
A.register(Registered)
instances = [B(), C(), Registered(), Other()]
num_threads = 8
iterations = 2000
barrier = threading.Barrier(num_threads + 2)
stop = threading.Event()
errors = []

def checker():
barrier.wait()
try:
for _ in range(iterations):
for cls in (A, B, C):
self.assertTrue(issubclass(C, cls))
self.assertFalse(issubclass(Other, cls))
self.assertFalse(isinstance(instances[3], cls))
self.assertTrue(isinstance(instances[0], A))
self.assertTrue(isinstance(instances[1], A))
self.assertTrue(isinstance(instances[2], A))
self.assertTrue(issubclass(Registered, A))
self.assertFalse(isinstance(instances[0], C))
except Exception as exc:
errors.append(exc)
finally:
stop.set()

def mutator():
barrier.wait()
i = 0
while not stop.is_set():
# Transient classes get cached, registered and destroyed.
Sub = type(f'Sub{i}', (B,), {})
Plain = type(f'Plain{i}', (), {})
self.assertTrue(issubclass(Sub, A))
self.assertFalse(issubclass(Plain, A))
A.register(Plain)
self.assertTrue(issubclass(Plain, A))
if i % 10 == 0:
A._abc_caches_clear()
B._abc_caches_clear()
if i % 50 == 0:
gc.collect()
i += 1

threads = [threading.Thread(target=checker) for _ in range(num_threads)]
threads += [threading.Thread(target=mutator) for _ in range(2)]
with threading_helper.start_threads(threads):
pass
self.assertEqual(errors, [])

@threading_helper.reap_threads
@threading_helper.requires_working_threading()
def test_concurrent_registry_clear(self):
class A(ABC):
pass
classes = [type(f'R{i}', (), {}) for i in range(32)]
barrier = threading.Barrier(4)

def worker():
barrier.wait()
for _ in range(500):
for cls in classes:
A.register(cls)
issubclass(cls, A)
A._abc_registry_clear()
A._abc_caches_clear()
with open(os.devnull, 'w') as f:
A._dump_registry(f)

threads = [threading.Thread(target=worker) for _ in range(4)]
with threading_helper.start_threads(threads):
pass


if __name__ == "__main__":
unittest.main()
Original file line number Diff line number Diff line change
@@ -0,0 +1,4 @@
Speed up :func:`isinstance` and :func:`issubclass` checks against
:class:`abc.ABCMeta` classes, fix quadratic time and memory usage for large
class hierarchies, and improve their scaling across threads in the
free-threaded build. Patch by Kumar Aditya.
Loading
Loading