Why does decorating a class break the descriptor protocol, thus preventing staticmethod objects from behaving as expected?

Question

I need a little bit of help understanding the subtleties of the descriptor protocol in Python, as it relates specifically to the behavior of `staticmethod` objects. I'll start with a trivial example, and then iteratively expand it, examining it's behavior at each step: ``` class Stub: @staticmethod def do_things(): """Call this like Stub.do_things(), with no arguments or instance.""" print "Doing things!" ``` At this point, this behaves as expected, but what's going on here is a bit subtle: When you call `Stub.do_things()`, you are not invoking do_things directly. Instead, `Stub.do_things` refers to a `staticmethod` instance, which has wrapped the function we want up inside it's own descriptor protocol such that you are actually invoking `staticmethod.__get__`, which first returns the function that we want, and then gets called afterwards. ``` >>> Stub >>> Stub.do_things >>> Stub.__dict__['do_things']

Accepted Answer

The problem is that you're changing the type of `Stub` from a class to a function. This is a pretty serious violation and it's not much surprise that things are breaking.

The technical reason that your `staticmethod`s are breaking is that `functools.wraps` works by copying `__name__`, `__doc__` and `__module__` etc. (source: http://hg.python.org/cpython/file/3.2/Lib/functools.py) from the wrapped instance to the wrapper, while updating the wrapper's `__dict__` from the wrapped instance's `__dict__`. It should be obvious now why `staticmethod` doesn't work - its descriptor protocol is being invoked on a function instead of a class, so it gives up on returning a bound callable and just returns its non-callable self.

w.r.t. actually doing what you're interested in (some kind of Singleton?), you probably want your decorator to return a class with a `__new__` that has the required behaviour. You don't need to be worried about `__init__` being called unwanted, as long as your wrapper class `__new__` doesn't actually return a value of the wrapper class type, rather an instance of the wrapped class:

```
def deco(wrapped_cls):
    @functools.wraps(wrapped_cls)
    class Wrapper(wrapped_cls):
        def __new__(cls, *args, **kwargs):
            ...
            return wrapped_cls(*args, **kwargs)
    return Wrapper
```

Note the distinction between the `wrapped_cls` argument to the decorator (that becomes closed over in the wrapper class) and the `cls` argument to `Wrapper.__new__`.

Note that it's perfectly OK to use `functools.wraps` on a class wrapping a class - just not on a class wrapping a function!

You can also modify the wrapped class, in which case you don't need `functools.wraps`:

```
def deco(wrapped_cls):
    def __new__(cls, *args, **kwargs)
        ...
        return super(wrapped_cls, cls)(*args, **kwargs)
    wrapped_cls.__new__ = classmethod(__new__)
    return wrapped_cls
```

Note however that this method will end up invoking `__init__` on existing instances, so you'll have to work around that (e.g. by wrapping `__init__` to short-circuit on existing instances).

As an addendum: it might be possible to make your function-wrapping-a-class decorator work in the cases you know about with a lot of effort, but you'll still run into problems - for example, `isinstance(myObject, Stub)` has no chance of working as `Stub` is no longer a `type`!

Why does decorating a class break the descriptor protocol, thus preventing staticmethod objects from behaving as expected?

Solution

Problem