Take a good look at this enormous answer/novel. It’s one of the best explanations I’ve come across. The shortest explanation that I can give is that decorators wrap your function in another function that returns a function. This code, for example: @decorate def foo(a): print a would be equivalent to this code if you remove … Read more
From wikipedia’s decorator pattern article: In object-oriented programming, the decorator pattern is a design pattern that allows new/additional behaviour to be added to an existing object dynamically. There’s no need to add toppings to a Pizza after it has been fully constructed. You don’t eat half a pizza and then add another topping to it. … Read more
Use –target ES5 –emitDecoratorMetadata –experimentalDecorators or use the following config: { “compilerOptions”: { “emitDecoratorMetadata”: true, “experimentalDecorators”: true, “target”: “ES5” } }
add a custom TypeScript decorator in a function Not to a raw function. The main issue is dealing with hoisting of functions. Any attempt to wrap a function in another function breaks the hoist. Support Targets A Decorator is a special kind of declaration that can be attached to a class declaration, method, accessor, property, … Read more
It is doable, and in fact I just found two snippets for this. Solution #1 The first snippet by cotton substitutes RegexURLPattern and RegexURLResolver with custom implementations that inject given decorator during resolve call. from django.core.urlresolvers import RegexURLPattern, RegexURLResolver from django.conf.urls.defaults import patterns, url, include from django.contrib import admin from myproject.myapp.decorators import superuser_required class DecoratedURLPattern(RegexURLPattern): … Read more
You don’t need to mess around with descriptors. It’s enough to create a wrapper function inside the __call__() method and return it. Standard Python functions can always act as either a method or a function, depending on context: class MyDecorator(object): def __init__(self, argument): self.arg = argument def __call__(self, fn): @functools.wraps(fn) def decorated(*args, **kwargs): print “In … Read more
There are some things about the autoassign code that bug me (mostly stylistic, but one more serious problem): autoassign does not assign an ‘args’ attribute: class Foo(object): @autoassign def __init__(self,a,b,c=False,*args): pass a=Foo(‘IBM’,’/tmp’,True, 100, 101) print(a.args) # AttributeError: ‘Foo’ object has no attribute ‘args’ autoassign acts like a decorator. But autoassign(*argnames) calls a function which returns … Read more
I’ve continued using this implementation at scale and in production with no issues. Decorator definition: def start_new_thread(function): def decorator(*args, **kwargs): t = Thread(target = function, args=args, kwargs=kwargs) t.daemon = True t.start() return decorator Example usage: @start_new_thread def foo(): #do stuff Over time, the stack has updated and transitioned without fail. Originally Python 2.4.7, Django 1.4, … Read more
It looks like functools.wraps does not do the job well enough, so it breaks py.test’s introspection. Creating the decorator using the decorator package seems to do the trick. import decorator def deco(func): def wrapper(func, *args, **kwargs): return func(*args, **kwargs) return decorator.decorator(wrapper, func)
classmethod and staticmethod return descriptor objects, not functions. Most decorators are not designed to accept descriptors. Normally, then, you must apply classmethod and staticmethod last when using multiple decorators. And since decorators are applied in “bottom up” order, classmethod and staticmethod normally should be top-most in your source. Like this: class My_class(object): @classmethod @print_function_name def … Read more