Add `PyType_Lookup()` function

[vstinner]

There is a private _PyType_Lookup() function which is used by 27 projects of the PyPI top 15,000 projects.

I propose to make the function public.

API: int PyType_Lookup(PyTypeObject *type, PyObject *name, PyObject **attr)

• Look for a type attribute through the type MRO. Do not invoke descriptors or metaclass __getattr__().
• name must be a str.
  • If found, set *attr to a strong reference and return 1.
  • If not found, set *attr to NULL and return 0.
  • On error, set an exception and return -1.
• Python pseudo-code (return AttributeError if not found):

       def PyType_Lookup(type, name):
           if not isinstance(name, str):
               raise TypeError
           for klass in type.mro():
               try:
                   return klass.__dict__[name]
               except KeyError:
                   pass
           # not found
           return AttributeError

The private PyObject* _PyType_Lookup(PyTypeObject *type, PyObject *name) API returns a borrowed reference, whereas the proposed public API returns a strong reference, and it returns NULL if not found or on error, whereas the public API is not ambiguous (no need to check PyErr_Occurred()).

See:

• issue
• pull request

Vote:

• @erlend-aasland
• @encukou
• @serhiy-storchaka
• @vstinner
• @zooba

[ronaldoussoren]

This function assumes that tp_getattro at some point defers to PyObject_GenericGetAttr (aka object.__getattr__). Some classes don't and hence won't work with this new function (in particular, PyObjC reimplements PyObject_GenericGetAttr with some customization).

Once upon a time I wrote the now dormant PEP 447 to make it possible to customize that algorithm a bit without fully replacing PyObject_GenericGetAttr. That PEP needs work to push it over the finish line, but that needs more available free time than I have had in ages :-(.

[encukou]

I guess the most important thing about the “Lookup” routine is not the exact behaviour (though it's important to document that), but the fact that Python uses it to find special methods.

Which is why it might be better to expose _PyObject_LookupSpecial or _PyObject_LookupSpecialMethod instead. I commented on the issue.

Also: Lookup is a rather generic term. Should we reserve the name for this?

[vstinner]

I looked at some projects to see how they are using _PyType_Lookup(): python/cpython#139847 (comment) Some projects are using directly _PyType_Lookup() output, whereas some others use tp_descr_get or tp_descr_set.

Which is why it might be better to expose _PyObject_LookupSpecial or _PyObject_LookupSpecialMethod instead. I commented on the issue.

_PyObject_LookupSpecial() is more specialized on method lookup, no? It seems to be more specific than PyType_Lookup().

I guess the most important thing about the “Lookup” routine is not the exact behaviour (though it's important to document that), but the fact that Python uses it to find special methods.

The function is not called PyObject_Lookup(), but PyType_Lookup(). It's already kinda special. It only looks into the type dictionary, as shown in the pseudo-code.