add pure Python fallback

Author: tanloong

Lib/test/test_types.py

@@ -41,10 +41,10 @@ def clear_typing_caches():
 class TypesTests(unittest.TestCase):
 
     def test_names(self):
-        c_only_names = {'CapsuleType', 'LazyImportType',
-                        'lookup_special_method'}
+        c_only_names = {'CapsuleType', 'LazyImportType'}
         ignored = {'new_class', 'resolve_bases', 'prepare_class',
-                   'get_original_bases', 'DynamicClassAttribute', 'coroutine'}
+                   'get_original_bases', 'DynamicClassAttribute', 'coroutine',
+                   'lookup_special_method'}
 
         for name in c_types.__all__:
             if name not in c_only_names | ignored:
@@ -727,7 +727,7 @@ def test_frame_locals_proxy_type(self):
         self.assertIsNotNone(frame)
         self.assertIsInstance(frame.f_locals, types.FrameLocalsProxyType)
 
-    def test_lookup_special_method(self):
+    def _test_lookup_special_method(self, lookup):
         class CM1:
             def __enter__(self):
                 return "__enter__ from class __dict__"
@@ -745,29 +745,36 @@ def __enter__(self):
                     return "__enter__ from __slots__"
                 self.__enter__ = __enter__
         cm1 = CM1()
-        meth = types.lookup_special_method(cm1, "__enter__")
+        meth = lookup(cm1, "__enter__")
         self.assertIsNotNone(meth)
         self.assertEqual(meth(cm1), "__enter__ from class __dict__")
 
-        meth = types.lookup_special_method(cm1, "__missing__")
+        meth = lookup(cm1, "__missing__")
         self.assertIsNone(meth)
 
         with self.assertRaises(TypeError):
-            types.lookup_special_method(cm1, 123)
+            lookup(cm1, 123)
 
         cm2 = CM2()
-        meth = types.lookup_special_method(cm2, "__enter__")
+        meth = lookup(cm2, "__enter__")
         self.assertIsNone(meth)
 
         cm3 = CM3()
-        meth = types.lookup_special_method(cm3, "__enter__")
+        meth = lookup(cm3, "__enter__")
         self.assertIsNotNone(meth)
         self.assertEqual(meth(cm3), "__enter__ from __slots__")
 
-        meth = types.lookup_special_method([], "__len__")
+        meth = lookup([], "__len__")
         self.assertIsNotNone(meth)
         self.assertEqual(meth([]), 0)
 
+    def test_lookup_special_method(self):
+        c_lookup = getattr(c_types, "lookup_special_method")
+        py_lookup = getattr(types, "lookup_special_method")
+        self._test_lookup_special_method(c_lookup)
+        self._test_lookup_special_method(py_lookup)
+
+
 class UnionTests(unittest.TestCase):
 
     def test_or_types_operator(self):

Lib/types.py

@@ -81,6 +81,54 @@ def _m(self): pass
 
     del sys, _f, _g, _C, _c, _ag, _cell_factory  # Not for export
 
+    def lookup_special_method(obj, attr, /):
+        """Lookup special method name `attr` on `obj`.
+
+        Lookup method `attr` on `obj` without looking in the instance
+        dictionary. For methods defined in class `__dict__` or `__slots__`, it
+        returns the unbound function (descriptor), not a bound method. The
+        caller is responsible for passing the object as the first argument when
+        calling it:
+
+            class A:
+                def __enter__(self):
+                    pass
+
+            class B:
+                __slots__ = ("__enter__",)
+
+                def __init__(self):
+                    def __enter__(self):
+                        pass
+                    self.__enter__ = __enter__
+
+            a = A()
+            b = B()
+            enter_a = types.lookup_special_method(a, "__enter__")
+            enter_b = types.lookup_special_method(b, "__enter__")
+
+            result_a = enter_a(a)
+            result_b = enter_b(b)
+
+        For other descriptors (property, etc.), it returns the result of the
+        descriptor's `__get__` method. Returns `None` if the method is not
+        found.
+        """
+        from inspect import getattr_static, isfunction, ismethoddescriptor
+        cls = type(obj)
+        try:
+            descr = getattr_static(cls, attr)
+        except AttributeError:
+            return None
+        if hasattr(descr, "__get__"):
+            if isfunction(descr) or ismethoddescriptor(descr):
+                # do not create bound method to mimic the behavior of
+                # _PyObject_LookupSpecialMethod
+                return descr
+            else:
+                return descr.__get__(obj, cls)
+        return descr
+
 
 # Provide a PEP 3115 compliant mechanism for class creation
 def new_class(name, bases=(), kwds=None, exec_body=None):

Modules/_typesmodule.c

@@ -24,14 +24,41 @@ _types.lookup_special_method
 
 Lookup special method name `attr` on `obj`.
 
-Lookup method `attr` on `obj` without looking in the instance dictionary.
-Returns `None` if the method is not found.
+Lookup method `attr` on `obj` without looking in the instance
+dictionary. For methods defined in class `__dict__` or `__slots__`, it
+returns the unbound function (descriptor), not a bound method. The
+caller is responsible for passing the object as the first argument when
+calling it:
+
+    class A:
+        def __enter__(self):
+            pass
+
+    class B:
+        __slots__ = ("__enter__",)
+
+        def __init__(self):
+            def __enter__(self):
+                pass
+            self.__enter__ = __enter__
+
+    a = A()
+    b = B()
+    enter_a = types.lookup_special_method(a, "__enter__")
+    enter_b = types.lookup_special_method(b, "__enter__")
+
+    result_a = enter_a(a)
+    result_b = enter_b(b)
+
+For other descriptors (property, etc.), it returns the result of the
+descriptor's `__get__` method. Returns `None` if the method is not
+found.
 [clinic start generated code]*/
 
 static PyObject *
 _types_lookup_special_method_impl(PyObject *module, PyObject *obj,
                                   PyObject *attr)
-/*[clinic end generated code: output=890e22cc0b8e0d34 input=f26012b0c90b81cd]*/
+/*[clinic end generated code: output=890e22cc0b8e0d34 input=fca9cb0e313a7848]*/
 {
     if (!PyUnicode_Check(attr)) {
         PyErr_Format(PyExc_TypeError,