tl; dr *Maybe* staticmethod could be modified to become callable? io.open is a built-in function (type "builtin_function_or_method"). It behaves differently than _pyio.open which is a Python function (type "function"). The difference is in the LOAD_METHOD bytecode which uses __get__() descriptor if available. Built-in function has no __get__() method and so the function is used directly as a method. Python function has a __get__() descriptor which returns the function unchanged when a class method is requested, and create a bound method if an instance method is requested: --- def func(): ... FunctionType = type(func) class MyClass: method = func class_method = MyClass.method assert class_method is func assert class_method is FunctionType.__get__(func, None, MyClass) obj = MyClass() instance_method = obj.method assert instance_method.__self__ is obj assert instance_method.__func__ is func # each __get__() call creates a new bound method assert instance_method == FunctionType.__get__(func, obj, type(obj)) --- @staticmethod decorator avoids the creation of the bound method: --- def func(): ... class MyClass: method = staticmethod(func) # method = MyClass.method attr = MyClass.__dict__['method'] method = type(attr).__get__(attr, None, MyClass) assert method is func --- The drawback is that the object created by staticmethod cannot be called :-( The following code raises a TypeError: --- wrapped = staticmethod(func) wrapped() --- *Maybe* staticmethod could be modified to become callable? Victor On Wed, Mar 31, 2021 at 2:34 PM Victor Stinner <vstinner@python.org> wrote:
Hi,
The io module provides an open() function. It also provides an OpenWrapper which only exists to be able to store open as a method (class or instance method). In the _pyio module, pure Python implementation of the io module, OpenWrapper is implemented as:
class OpenWrapper: """Wrapper for builtins.open
Trick so that open won't become a bound method when stored as a class variable (as dbm.dumb does).
See initstdio() in Python/pylifecycle.c. """ def __new__(cls, *args, **kwargs): return open(*args, **kwargs)
I would like to remove this class which is causing troubles in the PEP 597 implementation, but I don't know how. Simplified problem: --- def func(): print("my func")
class MyClass: method = func
func() # A MyClass.method() # B obj = MyClass() obj.method() # C ---
With this syntax, A and B work, but C fails with TypeError: func() takes 0 positional arguments but 1 was given.
If I decorate func() with @staticmethod, B and C work, but A fails with TypeError: 'staticmethod' object is not callable.
Is OpenWrapper the only way to have a callable object which works in the 3 variants A, B and C?
A, B and C work if MyClass is modified to use staticmethod:
class MyClass: method = staticmethod(func)
Victor -- Night gathers, and now my watch begins. It shall not end until my death.
-- Night gathers, and now my watch begins. It shall not end until my death.