Factor out Python version to a separate file

Lib/abc.py

@@ -4,30 +4,6 @@
 """Abstract Base Classes (ABCs) according to PEP 3119."""
 
 
-def get_cache_token():
-    """Returns the current ABC cache token.
-
-    The token is an opaque object (supporting equality testing) identifying the
-    current version of the ABC cache for virtual subclasses. The token changes
-    with every call to ``register()`` on any ABC.
-    """
-    return _Py_ABCMeta._abc_invalidation_counter
-
-
-from _weakrefset import WeakSet  # Used by legacy _Py_ABCMeta
-
-
-_C_speedup = False
-try:
-    from _abc import (get_cache_token, _abc_init, _abc_register,
-                      _abc_instancecheck, _abc_subclasscheck, _get_dump,
-                      _reset_registry, _reset_caches)
-except ImportError:
-    pass
-else:
-    _C_speedup = True
-
-
 def abstractmethod(funcobj):
     """A decorator indicating abstract methods.
 
@@ -125,191 +101,66 @@ def setx(self, value): ...
     __isabstractmethod__ = True
 
 
-class _Py_ABCMeta(type):
-    """Metaclass for defining Abstract Base Classes (ABCs).
-
-    Use this metaclass to create an ABC.  An ABC can be subclassed
-    directly, and then acts as a mix-in class.  You can also register
-    unrelated concrete classes (even built-in classes) and unrelated
-    ABCs as 'virtual subclasses' -- these and their descendants will
-    be considered subclasses of the registering ABC by the built-in
-    issubclass() function, but the registering ABC won't show up in
-    their MRO (Method Resolution Order) nor will method
-    implementations defined by the registering ABC be callable (not
-    even via super()).
-    """
-
-    # A global counter that is incremented each time a class is
-    # registered as a virtual subclass of anything.  It forces the
-    # negative cache to be cleared before its next use.
-    # Note: this counter is private. Use `abc.get_cache_token()` for
-    #       external code.
-    _abc_invalidation_counter = 0
-
-    def __new__(mcls, name, bases, namespace, **kwargs):
-        cls = super().__new__(mcls, name, bases, namespace, **kwargs)
-        # Compute set of abstract method names
-        abstracts = {name
-                     for name, value in namespace.items()
-                     if getattr(value, "__isabstractmethod__", False)}
-        for base in bases:
-            for name in getattr(base, "__abstractmethods__", set()):
-                value = getattr(cls, name, None)
-                if getattr(value, "__isabstractmethod__", False):
-                    abstracts.add(name)
-        cls.__abstractmethods__ = frozenset(abstracts)
-        # Set up inheritance registry
-        cls._abc_registry = WeakSet()
-        cls._abc_cache = WeakSet()
-        cls._abc_negative_cache = WeakSet()
-        cls._abc_negative_cache_version = _Py_ABCMeta._abc_invalidation_counter
-        return cls
-
-    def register(cls, subclass):
-        """Register a virtual subclass of an ABC.
-
-        Returns the subclass, to allow usage as a class decorator.
-        """
-        if not isinstance(subclass, type):
-            raise TypeError("Can only register classes")
-        if issubclass(subclass, cls):
-            return subclass  # Already a subclass
-        # Subtle: test for cycles *after* testing for "already a subclass";
-        # this means we allow X.register(X) and interpret it as a no-op.
-        if issubclass(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)
-        _Py_ABCMeta._abc_invalidation_counter += 1  # Invalidate negative cache
-        return subclass
-
-    def _dump_registry(cls, file=None):
-        """Debug helper to print the ABC registry."""
-        print(f"Class: {cls.__module__}.{cls.__qualname__}", file=file)
-        print(f"Inv. counter: {get_cache_token()}", file=file)
-        for name in cls.__dict__:
-            if name.startswith("_abc_"):
-                value = getattr(cls, name)
-                if isinstance(value, WeakSet):
-                    value = set(value)
-                print(f"{name}: {value!r}", file=file)
-
-    def _abc_registry_clear(cls):
-        """Clear the registry (for debugging or testing)."""
-        cls._abc_registry.clear()
-
-    def _abc_caches_clear(cls):
-        """Clear the caches (for debugging or testing)."""
-        cls._abc_cache.clear()
-        cls._abc_negative_cache.clear()
-
-    def __instancecheck__(cls, instance):
-        """Override for isinstance(instance, cls)."""
-        # Inline the cache checking
-        subclass = instance.__class__
-        if subclass in cls._abc_cache:
-            return True
-        subtype = type(instance)
-        if subtype is subclass:
-            if (cls._abc_negative_cache_version ==
-                _Py_ABCMeta._abc_invalidation_counter and
-                subclass in cls._abc_negative_cache):
-                return False
-            # Fall back to the subclass check.
-            return cls.__subclasscheck__(subclass)
-        return any(cls.__subclasscheck__(c) for c in {subclass, subtype})
-
-    def __subclasscheck__(cls, subclass):
-        """Override for issubclass(subclass, cls)."""
-        # Check cache
-        if subclass in cls._abc_cache:
-            return True
-        # Check negative cache; may have to invalidate
-        if cls._abc_negative_cache_version < _Py_ABCMeta._abc_invalidation_counter:
-            # Invalidate the negative cache
-            cls._abc_negative_cache = WeakSet()
-            cls._abc_negative_cache_version = _Py_ABCMeta._abc_invalidation_counter
-        elif subclass in cls._abc_negative_cache:
-            return False
-        # Check the subclass hook
-        ok = cls.__subclasshook__(subclass)
-        if ok is not NotImplemented:
-            assert isinstance(ok, bool)
-            if ok:
-                cls._abc_cache.add(subclass)
-            else:
-                cls._abc_negative_cache.add(subclass)
-            return ok
-        # Check if it's a direct subclass
-        if cls in getattr(subclass, '__mro__', ()):
-            cls._abc_cache.add(subclass)
-            return True
-        # Check if it's a subclass of a registered class (recursive)
-        for rcls in cls._abc_registry:
-            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)
-                return True
-        # No dice; update negative cache
-        cls._abc_negative_cache.add(subclass)
-        return False
-
-
-class _C_ABCMeta(type):
-    def __new__(mcls, name, bases, namespace, **kwargs):
-        cls = super().__new__(mcls, name, bases, namespace, **kwargs)
-        _abc_init(cls)
-        return cls
-
-    def register(cls, subclass):
-        """Register a virtual subclass of an ABC.
-
-        Returns the subclass, to allow usage as a class decorator.
-        """
-        return _abc_register(cls, subclass)
-
-    def __instancecheck__(cls, instance):
-        """Override for isinstance(instance, cls)."""
-        return _abc_instancecheck(cls, instance)
-
-    def __subclasscheck__(cls, subclass):
-        """Override for issubclass(subclass, cls)."""
-        return _abc_subclasscheck(cls, subclass)
-
-    def _dump_registry(cls, file=None):
-        """Debug helper to print the ABC registry."""
-        print(f"Class: {cls.__module__}.{cls.__qualname__}", file=file)
-        print(f"Inv. counter: {get_cache_token()}", file=file)
-        (_abc_registry, _abc_cache, _abc_negative_cache,
-         _abc_negative_cache_version) = _get_dump(cls)
-        print(f"_abc_registry: {_abc_registry!r}", file=file)
-        print(f"_abc_cache: {_abc_cache!r}", file=file)
-        print(f"_abc_negative_cache: {_abc_negative_cache!r}", file=file)
-        print(f"_abc_negative_cache_version: {_abc_negative_cache_version!r}",
-              file=file)
-
-    def _abc_registry_clear(cls):
-        """Clear the registry (for debugging or testing)."""
-        _reset_registry(cls)
-
-    def _abc_caches_clear(cls):
-        """Clear the caches (for debugging or testing)."""
-        _reset_caches(cls)
-
-
-if _C_speedup:
-    ABCMeta = _C_ABCMeta
+try:
+    from _abc import (get_cache_token, _abc_init, _abc_register,
+                      _abc_instancecheck, _abc_subclasscheck, _get_dump,
+                      _reset_registry, _reset_caches)
+except ImportError:
+    from _py_abc import ABCMeta, get_cache_token
 else:
-    ABCMeta = _Py_ABCMeta
-
-_C_ABCMeta.__doc__ = _Py_ABCMeta.__doc__
+    class ABCMeta(type):
+        """Metaclass for defining Abstract Base Classes (ABCs).
+
+        Use this metaclass to create an ABC.  An ABC can be subclassed
+        directly, and then acts as a mix-in class.  You can also register
+        unrelated concrete classes (even built-in classes) and unrelated
+        ABCs as 'virtual subclasses' -- these and their descendants will
+        be considered subclasses of the registering ABC by the built-in
+        issubclass() function, but the registering ABC won't show up in
+        their MRO (Method Resolution Order) nor will method
+        implementations defined by the registering ABC be callable (not
+        even via super()).
+        """
+        def __new__(mcls, name, bases, namespace, **kwargs):
+            cls = super().__new__(mcls, name, bases, namespace, **kwargs)
+            _abc_init(cls)
+            return cls
+
+        def register(cls, subclass):
+            """Register a virtual subclass of an ABC.
+
+            Returns the subclass, to allow usage as a class decorator.
+            """
+            return _abc_register(cls, subclass)
+
+        def __instancecheck__(cls, instance):
+            """Override for isinstance(instance, cls)."""
+            return _abc_instancecheck(cls, instance)
+
+        def __subclasscheck__(cls, subclass):
+            """Override for issubclass(subclass, cls)."""
+            return _abc_subclasscheck(cls, subclass)
+
+        def _dump_registry(cls, file=None):
+            """Debug helper to print the ABC registry."""
+            print(f"Class: {cls.__module__}.{cls.__qualname__}", file=file)
+            print(f"Inv. counter: {get_cache_token()}", file=file)
+            (_abc_registry, _abc_cache, _abc_negative_cache,
+             _abc_negative_cache_version) = _get_dump(cls)
+            print(f"_abc_registry: {_abc_registry!r}", file=file)
+            print(f"_abc_cache: {_abc_cache!r}", file=file)
+            print(f"_abc_negative_cache: {_abc_negative_cache!r}", file=file)
+            print(f"_abc_negative_cache_version: {_abc_negative_cache_version!r}",
+                  file=file)
+
+        def _abc_registry_clear(cls):
+            """Clear the registry (for debugging or testing)."""
+            _reset_registry(cls)
+
+        def _abc_caches_clear(cls):
+            """Clear the caches (for debugging or testing)."""
+            _reset_caches(cls)
 
-_C_ABCMeta.__name__ = _C_ABCMeta.__qualname__ = 'ABCMeta'
-_Py_ABCMeta.__name__ = _Py_ABCMeta.__qualname__ = 'ABCMeta'
 
 
 class ABC(metaclass=ABCMeta):

Lib/test/test_abc.py

@@ -1,17 +1,18 @@
 # Copyright 2007 Google, Inc. All Rights Reserved.
 # Licensed to PSF under a Contributor Agreement.
 
-# Note: each test is run with _Py_ABCMeta and _C_ABCMeta, except for two tests, where we
-# need to "sync" with actual abc.ABCMeta, these tests check get_cache_token and ABC helper.
+# Note: each test is run with Python and C versions of ABCMeta. Except for
+# test_ABC_helper(), which assures that abc.ABC is an instance of abc.ABCMeta.
 
 """Unit tests for abc.py."""
 
 import unittest
 
 import abc
+import _py_abc
 from inspect import isabstract
 
-def test_factory(abc_ABCMeta):
+def test_factory(abc_ABCMeta, abc_get_cache_token):
     class TestLegacyAPI(unittest.TestCase):
 
         def test_abstractproperty_basics(self):
@@ -296,16 +297,16 @@ class C(B):
             self.assertIs(C, A.register(C))
 
         def test_isinstance_invalidation(self):
-            class A(metaclass=abc.ABCMeta):
+            class A(metaclass=abc_ABCMeta):
                 pass
             class B:
                 pass
             b = B()
             self.assertFalse(isinstance(b, A))
             self.assertFalse(isinstance(b, (A,)))
-            token_old = abc.get_cache_token()
+            token_old = abc_get_cache_token()
             A.register(B)
-            token_new = abc.get_cache_token()
+            token_new = abc_get_cache_token()
             self.assertNotEqual(token_old, token_new)
             self.assertTrue(isinstance(b, A))
             self.assertTrue(isinstance(b, (A,)))
@@ -423,18 +424,22 @@ class C(with_metaclass(abc_ABCMeta, A, B)):
 
     class TestABCWithInitSubclass(unittest.TestCase):
         def test_works_with_init_subclass(self):
+            class abc_ABC(metaclass=abc_ABCMeta):
+                __slots__ = ()
             saved_kwargs = {}
             class ReceivesClassKwargs:
                 def __init_subclass__(cls, **kwargs):
                     super().__init_subclass__()
                     saved_kwargs.update(kwargs)
-            class Receiver(ReceivesClassKwargs, abc.ABC, x=1, y=2, z=3):
+            class Receiver(ReceivesClassKwargs, abc_ABC, x=1, y=2, z=3):
                 pass
             self.assertEqual(saved_kwargs, dict(x=1, y=2, z=3))
     return TestLegacyAPI, TestABC, TestABCWithInitSubclass
 
-TestLegacyAPI_Py, TestABC_Py, TestABCWithInitSubclass_Py = test_factory(abc._Py_ABCMeta)
-TestLegacyAPI_C, TestABC_C, TestABCWithInitSubclass_C = test_factory(abc._C_ABCMeta)
+TestLegacyAPI_Py, TestABC_Py, TestABCWithInitSubclass_Py = test_factory(abc.ABCMeta,
+                                                                        abc.get_cache_token)
+TestLegacyAPI_C, TestABC_C, TestABCWithInitSubclass_C = test_factory(_py_abc.ABCMeta,
+                                                                     _py_abc.get_cache_token)
 
 if __name__ == "__main__":
     unittest.main()