OK, I cheated.<\/p>\n
In yesterday’s post on writing decorator classes that decorate methods<\/a>, I left out two edge cases that can’t be completely ignored: static methods and class methods.<\/p>\n To illustrate, I’ll start where I left off<\/a> yesterday, adding a decorated class method and a decorated static method to the example:<\/p>\n Running this gives an error:<\/p>\n Just for this example, I’ll try removing the “Tracing<\/strong>” print call; but still no joy:<\/p>\n The essential problem is that class methods and static methods are not callable.1<\/sup><\/a> There’s an easy enough workaround: always use That produces the desired result:<\/p>\n But suppose we really, really need<\/em> to decorate an already-decorated classmethod or staticmethod. The key lies again in the descriptor protocol<\/a>.<\/p>\n First, we need to modify the decorator’s The new In the decorator’s Wait\u00e2\u20ac\u201dwhy didn’t we do this in Note that we return with<\/p>\n However, this results in any side effects in the decorator’s __init__ method being re-executed for every call to the decorated method. Note the additional “Tracing:<\/strong>” lines in the output here:<\/p>\n Another option, of course, is to use a mutex around the statement that modifies The decorator’s Here’s the entire decorator, as revised:<\/p>\n I’ve tested this with Python 2.6, 2.7, and 3.1.<\/p>\n 1<\/sup><\/a> Without taking a deep dive into Python’s history, I couldn’t say why<\/em> they’re not callable. But it does seem that class methods and static methods were never intended to be used frequently<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":" Yesterday’s entry on Python decorator classes left out two related edge cases: classmethod objects and staticmethod objects.<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[30],"tags":[50,31,32],"_links":{"self":[{"href":"https:\/\/www.outofwhatbox.com\/blog\/wp-json\/wp\/v2\/posts\/650"}],"collection":[{"href":"https:\/\/www.outofwhatbox.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.outofwhatbox.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.outofwhatbox.com\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.outofwhatbox.com\/blog\/wp-json\/wp\/v2\/comments?post=650"}],"version-history":[{"count":4,"href":"https:\/\/www.outofwhatbox.com\/blog\/wp-json\/wp\/v2\/posts\/650\/revisions"}],"predecessor-version":[{"id":658,"href":"https:\/\/www.outofwhatbox.com\/blog\/wp-json\/wp\/v2\/posts\/650\/revisions\/658"}],"wp:attachment":[{"href":"https:\/\/www.outofwhatbox.com\/blog\/wp-json\/wp\/v2\/media?parent=650"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.outofwhatbox.com\/blog\/wp-json\/wp\/v2\/categories?post=650"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.outofwhatbox.com\/blog\/wp-json\/wp\/v2\/tags?post=650"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\r\nimport types\r\n\r\nclass DebugTrace(object):\r\n def __init__(self, f):\r\n print("Tracing: {0}".format(f.__name__))\r\n self.f = f\r\n\r\n def __get__(self, obj, ownerClass=None):\r\n # Return a wrapper that binds self as a method of obj (!)\r\n return types.MethodType(self, obj)\r\n\r\n def __call__(self, *args, **kwargs):\r\n print("Calling: {0}".format(self.f.__name__))\r\n return self.f(*args, **kwargs)\r\n\r\n\r\nclass Greeter(object):\r\n instances = 0\r\n\r\n def __init__(self):\r\n Greeter.instances += 1\r\n self._inst = Greeter.instances\r\n\r\n @DebugTrace\r\n def hello(self):\r\n print("*** Greeter {0} says hello!".format(self._inst))\r\n\r\n @DebugTrace\r\n @classmethod\r\n def classHello(cls, to):\r\n print("*** The {0} class says hello to {1}".format(cls.__name__, to))\r\n\r\n @DebugTrace\r\n @staticmethod\r\n def staticHello(to):\r\n print("*** Something says hello to " + to)\r\n\r\n\r\n@DebugTrace\r\ndef greet():\r\n g = Greeter()\r\n g2 = Greeter()\r\n g.hello()\r\n g2.hello()\r\n Greeter.staticHello("you")\r\n Greeter.classHello("everyone")\r\n\r\ngreet()\r\n<\/pre>\n\r\n\r\nTracing: hello\r\nTraceback (most recent call last):\r\n File "DecoratorExample.py", line 17, in <module>\r\n class Greeter(object):\r\n File "DecoratorExample.py", line 29, in Greeter\r\n @classmethod\r\n File "DecoratorExample.py", line 5, in __init__\r\n print("Tracing: {0}".format(f.__name__))\r\nAttributeError: 'classmethod' object has no attribute '__name__'\r\n<\/pre>\n\r\nCalling: greet\r\nCalling: hello\r\n*** Greeter 1 says hello!\r\nCalling: hello\r\n*** Greeter 2 says hello!\r\nTraceback (most recent call last):\r\n File "DecoratorExample.py", line 48, in <module>\r\n greet()\r\n File "DecoratorExample.py", line 14, in __call__\r\n return self.f(*args, **kwargs)\r\n File "DecoratorExample.py", line 45, in greet\r\n Greeter.staticHello("you")\r\n File "DecoratorExample.py", line 10, in __get__\r\n return types.MethodType(self, obj)\r\nTypeError: self must not be None\r\n<\/pre>\n@staticmethod<\/code> or @classmethod<\/code> as the outermost<\/em> (i.e., last) decorator in a sequence, as in:<\/p>\n\r\n @classmethod\r\n @DebugTrace\r\n def classHello(cls, to):\r\n print("*** The Greeter class says hello to " + to)\r\n\r\n @staticmethod\r\n @DebugTrace\r\n def staticHello(to):\r\n print("*** Something says hello to " + to)\r\n<\/pre>\n\r\nTracing: hello\r\nTracing: classHello\r\nTracing: staticHello\r\nTracing: greet\r\nCalling: greet\r\nCalling: hello\r\n*** Greeter 1 says hello!\r\nCalling: hello\r\n*** Greeter 2 says hello!\r\nCalling: staticHello\r\n*** Something says hello to you\r\nCalling: classHello\r\n*** The Greeter class says hello to everyone\r\n<\/pre>\n
__init__<\/code> method. (Note that the only<\/em> reason that we need to modify __init__<\/code> is to find the name of the classmethod or staticmethod that’s being decorated. If we didn’t produce the “Tracing:<\/strong>” output, we could leave __init__ <\/code>alone.)<\/p>\n__init__<\/code> method detects whether the passed “function” has a __call__<\/code> method. If it doesn’t, then it’s reasonable to assume that it’s a classmethod or a staticmethod. Calling the object’s __get__<\/code> method returns a function object, from which we can get the function name:<\/p>\n\r\n def __init__(self, f):\r\n self.f = f\r\n if hasattr(f, "__call__"):\r\n name = self.f.__name__\r\n else:\r\n # f is a class or static method.\r\n tmp = f.__get__(None, f.__class__)\r\n name = tmp.__name__\r\n print("Tracing: {0}".format(name))\r\n<\/pre>\n__get__<\/code> method, we’ll know that we’re dealing with a staticmethod or classmethod if the passed obj<\/code> has the value None<\/code>. If that’s the case, then we make a one-time adjustment to self.f<\/code>, ensuring that it points to the underlying function.<\/p>\nDebugTrace.__init__<\/code>?<\/em> It may seem redundant, but the call to f.__get__<\/code> that we made in DebugTrace.__init__<\/code> doesn’t count: that call didn’t specify the class that f<\/code> actually belongs to. (Any<\/em> class works for the purpose of getting the function’s name.) Now that we’re in DebugTrace.__get__<\/code>, we know via the ownerClass<\/code> parameter the class that self.f<\/code> is associated with. This class may make its way into a classmethod call (e.g., the call to Greeter.classHello<\/code>), so it matters that we get it right.<\/p>\nself<\/code> in this case. We don’t want to create a new method object for classmethods or staticmethods; just calling self.__call__<\/code> will call the method appropriately.<\/p>\n\r\n def __get__(self, obj, ownerClass=None):\r\n if obj is None:\r\n f = self.f\r\n if not hasattr(f, "__call__"):\r\n self.f = f.__get__(None, ownerClass)\r\n return self\r\n else:\r\n # Return a wrapper that binds self as a method of obj (!)\r\n return types.MethodType(self, obj)\r\n<\/pre>\n
self.f<\/code> as above might raise thread-safety issues, especially if you don’t want to rely on the atomicity of modifying a dict<\/a> in-place. Borrowing from Ian Bicking’s solution<\/a>, which returns a copy of the decorator for each call to __get__<\/code>, can help us dodge the concurrency bullet. We’d replace <\/p>\n\r\n return self\r\n<\/pre>\n
\r\n return self.__class__(self.f)\r\n<\/pre>\n
\r\nTracing: hello\r\nTracing: classHello\r\nTracing: staticHello\r\nTracing: greet\r\nCalling: greet\r\nCalling: hello\r\n*** Greeter 1 says hello!\r\nCalling: hello\r\n*** Greeter 2 says hello!\r\nTracing: staticHello\r\nCalling: staticHello\r\n*** Something says hello to you\r\nTracing: classHello\r\nCalling: classHello\r\n*** The Greeter class says hello to everyone\r\n<\/pre>\n
self.f<\/code>.\n<\/div>\n__call__<\/code> method is unchanged from yesterday’s example. As before, it simply prints out the desired trace message, then invokes self.f<\/code>.<\/p>\n\r\nimport types\r\n\r\nclass DebugTrace(object):\r\n def __init__(self, f):\r\n self.f = f\r\n if hasattr(f, "__call__"):\r\n name = self.f.__name__\r\n else:\r\n # f is a class or static method\r\n tmp = f.__get__(None, f.__class__)\r\n name = tmp.__name__\r\n print("Tracing: {0}".format(name))\r\n\r\n def __get__(self, obj, ownerClass=None):\r\n if obj is None:\r\n f = self.f\r\n if not hasattr(f, "__call__"):\r\n self.f = f.__get__(None, ownerClass)\r\n return self\r\n else:\r\n # Return a wrapper that binds self as a method of obj (!)\r\n return types.MethodType(self, obj)\r\n\r\n def __call__(self, *args, **kwargs):\r\n print("Calling: {0}".format(self.f.__name__))\r\n return self.f(*args, **kwargs)\r\n\r\n\r\nclass Greeter(object):\r\n instances = 0\r\n\r\n def __init__(self):\r\n Greeter.instances += 1\r\n self._inst = Greeter.instances\r\n\r\n @DebugTrace\r\n def hello(self):\r\n print("*** Greeter {0} says hello!".format(self._inst))\r\n\r\n @DebugTrace\r\n @classmethod\r\n def classHello(cls, to):\r\n print("*** The {0} class says hello to {1}".format(cls.__name__, to))\r\n\r\n @DebugTrace\r\n @staticmethod\r\n def staticHello(to):\r\n print("*** Something says hello to " + to)\r\n\r\n\r\n@DebugTrace\r\ndef greet():\r\n g = Greeter()\r\n g2 = Greeter()\r\n g.hello()\r\n g2.hello()\r\n Greeter.staticHello("you")\r\n Greeter.classHello("everyone")\r\n\r\ngreet()\r\n<\/pre>\n
\n