First, most of the time you think you need something like this, you don’t; it’s a sign that you’re trying to treat Python like Java, and the solution is to step back and ask why you need a factory. Often, the simplest thing to do is to just have a constructor with defaulted/optional/keyword arguments. Even … Read more
def upper(f): @wrap def uppercase(*args, **kargs): a,b = f(*args, **kargs) return a.upper(), b.upper() return uppercase A decorator in Python @foo def bar(…): … is just equivalent to def bar(…): … bar = foo(bar) You want to get the effect of @wrap @upper def hello(): …. i.e. hello = wrap(upper(hello)) so the wrap should be called … Read more
I had the same problem with the celery @task decorator. You can also fix this in your case by adding the correct function signature to your rst file, like this: .. autoclass:: Bus :members: .. automethod:: open(self) .. automethod:: some_other_method(self, param1, param2) It will still document the non-decorator members automatically. This is mentioned in the … Read more
Decorators are just syntactic sugar to replace a function object with a decorated version, where decorating is just calling (passing in the original function object). In other words, the syntax: @decorator_expression def function_name(): # function body roughly(*) translates to: def function_name(): # function body function_name = decorator_expression(function_name) In your case, you can apply your decorator … Read more
Use a Metaclass I would recommend Method #2, but you’re better off using a metaclass than a base class. Here is a sample implementation: class Singleton(type): _instances = {} def __call__(cls, *args, **kwargs): if cls not in cls._instances: cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs) return cls._instances[cls] class Logger(object): __metaclass__ = Singleton Or in Python3 class Logger(metaclass=Singleton): … Read more
Decorator Pattern – In object-oriented programming, the decorator pattern is a design pattern that allows behaviour to be added to an existing object dynamically. The decorator pattern can be used to extend (decorate) the functionality of a certain object at run-time, independently of other instances of the same class, provided some groundwork is done at … Read more
Decorator uses Delegation, but in a very specific way. Delegation (or composition) is not as much a pattern as a general way to build complex behavior by coordinating use of several other objects. It’s often used in a set or static way. By “set or static” I mean something like this: class Delegator { private … Read more
May be you can find better way to do it, but, for example, you can just move your wrapping logic to some context manager to prevent code duplication: import asyncio import functools import time from contextlib import contextmanager def duration(func): @contextmanager def wrapping_logic(): start_ts = time.time() yield dur = time.time() – start_ts print(‘{} took {:.2} … Read more
f = anotherdecorator(lambda x: x * 2)
Suppose you create a View class that displays your items in a certain way. Now you decide you also want a version of it which is scrollable, so you create a ScrollableView which inherits the View. Later you decide you also want a version with a border so you now need to make a BorderedView … Read more