unexpected behavior when assigning a FunctionWrapper to a static variable about wrapt HOT 4 CLOSED

>>> class Test:
...     def a(self):
...         pass
...
>>> Test.a
<unbound method Test.a>

>>> class X(object):
    def g():pass

>>> X.g
<unbound method X.g>
>>> class B:
    def __get__(self, *args):
        print(args)

>>> X.b = B()
>>> X.b
<__main__.B instance at 0x029C0440>

from __future__ import print_function

class X(object):
    def im(self): pass

    @staticmethod
    def sm(): pass

    @classmethod
    def cm(cls): pass

def dump(m):
    print('name', m.__name__)

    print('type', type(m))

    try:
        print('__self__', m.__self__)
    except AttributeError:
        print('__self__', '<UNDEFINED>')

    print()

dump(X.im)
dump(X().im)

dump(X.sm)
dump(X().sm)

dump(X.cm)
dump(X().cm)

$ python2.7 bind.py
name im
type <type 'instancemethod'>
__self__ None

name im
type <type 'instancemethod'>
__self__ <__main__.X object at 0x102c500d0>

name sm
type <type 'function'>
__self__ <UNDEFINED>

name sm
type <type 'function'>
__self__ <UNDEFINED>

name cm
type <type 'instancemethod'>
__self__ <class '__main__.X'>

name cm
type <type 'instancemethod'>
__self__ <class '__main__.X'>

$ python3.4 bind.py
name im
type <class 'function'>
__self__ <UNDEFINED>

name im
type <class 'method'>
__self__ <__main__.X object at 0x10063fb00>

name sm
type <class 'function'>
__self__ <UNDEFINED>

name sm
type <class 'function'>
__self__ <UNDEFINED>

name cm
type <class 'method'>
__self__ <class '__main__.X'>

name cm
type <class 'method'>
__self__ <class '__main__.X'>

from __future__ import print_function

from wrapt import FunctionWrapper

class A(FunctionWrapper):
    A = None

    def __init__(self, f):
        super(A, self).__init__(f, self.wrapper)

    def wrapper(self, wrapped, instance, args, kwargs):
        print('wrapper', wrapped, instance, args, kwargs)
        return wrapped(*args, **kwargs)

@A
def f(*args, **kwargs):
    pass


print(type(f))
A.A = f

m = A.A
print(type(m))
print(m.__self__)

b = m.__get__(A, None)

b()

<class '__main__.A'>
<type 'BoundFunctionWrapper'>
None
wrapper <bound method ?.f of <class '__main__.A'>> <class '__main__.A'> () {}

A.m = wrapper(A.m)

wrapt.wrap_object(B, 'm', wrapper)

from __future__ import print_function

import wrapt

@wrapt.decorator
def wrapper(wrapped, instance, args, kwargs):
    print(wrapped, instance, args, kwargs)
    return wrapped(*args, **kwargs)

class A(object):
    def m(self):
        pass

# BAD: Don't do this.

A.m = wrapper(A.m)

a = A()

a.m()

class B(object):
    def m(self):
        pass

# GOOD: This is the preferred way when monkey patching method of existing class definition.

wrapt.wrap_object(B, 'm', wrapper)

b = B()

b.m()

        # We can't just always use getattr() because in doing
        # that on a class it will cause binding to occur which
        # will complicate things later and cause some things not
        # to work. For the case of a class we therefore access
        # the __dict__ directly. To cope though with the wrong
        # class being given to us, or a method being moved into
        # a base class, we need to walk the class heirarchy to
        # work out exactly which __dict__ the method was defined
        # in, as accessing it from __dict__ will fail if it was
        # not actually on the class given. Fallback to using
        # getattr() if we can't find it. If it truly doesn't
        # exist, then that will fail.