Now, the decorators in Python work from the inside out Well I guess that depends on your definition of inside out. In your case, you want @login_required to execute first, and so it should be the “outermost” (top) decorator. As you noted, your last example works, and is indeed the correct way to do this. … Read more
For read-only properties I use the decorator, else I usually do something like this: class Bla(object): def sneaky(): def fget(self): return self._sneaky def fset(self, value): self._sneaky = value return locals() sneaky = property(**sneaky()) update: Recent versions of python enhanced the decorator approach: class Bla(object): @property def elegant(self): return self._elegant @elegant.setter def elegant(self, value): self._elegant = … Read more
@Cache(max_hits=100, timeout=50) calls __init__(max_hits=100, timeout=50), so you aren’t satisfying the function argument. You could implement your decorator via a wrapper method that detected whether a function was present. If it finds a function, it can return the Cache object. Otherwise, it can return a wrapper function that will be used as the decorator. class _Cache(object): … Read more
I would code it as two different methods just like in standard method factory pattern description. https://www.oodesign.com/factory-method-pattern.html class Foo(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod @some_decorator def my_method(self, x): self.child_method() class SubFoo(Foo): def child_method(self, x): print x
A do-nothing decorator class would look like this: class NullDecl (object): def __init__ (self, func): self.func = func for name in set(dir(func)) – set(dir(self)): setattr(self, name, getattr(func, name)) def __call__ (self, *args): return self.func (*args) And then you can apply it normally: @NullDecl def myFunc (x,y,z): return (x+y)/z
Another approach, thanks to a suggestion from @DarkSquirrel42, is to use an InjectionFactory. The downside is that the code still needs updating every time a new constructor parameter is added to something in the chain. The advantages are much easier to understand code, and only a single registration into the container. Func<IUnityContainer,object> createChain = container … Read more
Better one and a half year late than never: A base class for decorators of a certain interface is not necessary. However, it is very useful to have: for one thing, as a means of documenting that classes derived from it are decorators of the interface in question but mostly, because decorators usually do not … Read more
I would use a retry decorator. There are other ones out there, but this one works pretty well. Here’s how you can use it: @retry(urllib2.URLError, tries=4, delay=3, backoff=2) def urlopen_with_retry(): return urllib2.urlopen(“http://example.com”) This will retry the function if URLError is raised. Check the link above for documentation on the parameters, but basically it will retry … Read more
I’m surprised that this question is so old and no one has taken the time to add the actual introspective way to do this, so here it is: The code you want to inspect… def template(func): def wrapper(*args, **kwargs): return func(*args, **kwargs) return wrapper baz = template che = template class Foo(object): @baz @che def … Read more
the __exit__() method should accept information about exceptions that come up in the with: block. See here. The following modification of your code works: def __exit__(self, exc_type, exc_value, tb): if exc_type is not None: traceback.print_exception(exc_type, exc_value, tb) # return False # uncomment to pass exception through return True Then you can try raising an exception … Read more