[Python-ideas] Make functions, methods and descriptor types living in the types module

Guido van Rossum guido at python.org
Sat Jan 13 00:19:47 EST 2018

On Thu, Jan 11, 2018 at 8:45 PM, Steve Dower <steve.dower at python.org> wrote:

> I certainly have code that joins __module__ with __name__ to create a
> fully-qualified name (with special handling for those builtins that are not
> in builtins), and IIUC __qualname__ doesn't normally include the module
> name either (it's intended for nested types/functions).

In fact __qualname__ should never include the module. It should however
include the containing class(es). E.g. for

# __main__.py:
class Outer:
  class Inner:
    def f(self): pass

print(Outer.Inner.f.__name__)  # 'f'
print(Outer.Inner.f.__qualname__)  # 'Outer.Inner.f'
print(Outer.Inner.f.__module__)  # '__main__'

IMO the current __module__ for these objects is just wrong (since they
aren't in builtins -- even though they are "built in"). So in principle it
should be okay to set it to 'types'. (Except I wish we didn't have the
types module at all, but that's water under the bridge.)

In practice I expect there to be some failing tests. Maybe investigate this
for Python 3.8?

> Can we make it visible when you import the builtins module, but not in the
> builtins namespace?

That would violate the very definition of the builtins module.

PS. There are probably many more of these. E.g. NoneType, dict_keys, etc.


On 12Jan2018 0941, Victor Stinner wrote:
>> I like the idea of having a fully qualified name that "works" (can be
>> resolved).
>> I don't think that repr() should change, right?
>> Can this change break the backward compatibility somehow?
>> Victor
>> Le 11 janv. 2018 21:00, "Serhiy Storchaka" <storchaka at gmail.com
>> <mailto:storchaka at gmail.com>> a écrit :
>>     Currently the classes of functions (implemented in Python and
>>     builtin), methods, and different type of descriptors, generators,
>>     etc have the __module__ attribute equal to "builtins"  and the name
>>     that can't be used for accessing the class.
>>     >>> def f(): pass
>>     ...
>>     >>> type(f)
>>     <class 'function'>
>>     >>> type(f).__module__
>>     'builtins'
>>     >>> type(f).__name__
>>     'function'
>>     >>> type(f).__qualname__
>>     'function'
>>     >>> import builtins
>>     >>> builtins.function
>>     Traceback (most recent call last):
>>       File "<stdin>", line 1, in <module>
>>     AttributeError: module 'builtins' has no attribute 'function'
>>     But most of this classes (if not all) are exposed in the types module.
>>     I suggest to rename them. Make the __module__ attribute equal to
>>     "builtins" and the __name__ and the __qualname__ attributes equal to
>>     the name used for accessing the class in the types module.
>>     This would allow to pickle references to these types. Currently this
>>     isn't possible.
>>     >>> pickle.dumps(types.FunctionType)
>>     Traceback (most recent call last):
>>       File "<stdin>", line 1, in <module>
>>     _pickle.PicklingError: Can't pickle <class 'function'>: attribute
>>     lookup function on builtins failed
>>     And this will help to implement the pickle support of dynamic
>>     functions etc. Currently the third-party library that implements
>>     this needs to use a special purposed factory function (not
>>     compatible with other similar libraries) since types.FunctionType
>>     isn't pickleable.
--Guido van Rossum (python.org/~guido)
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-ideas/attachments/20180112/b67c5a0b/attachment.html>

More information about the Python-ideas mailing list