Popular recipes tagged "decorators"

Decorator for defining functions with keyword-only arguments (Python)

2015-07-10T15:25:04-07:00

Python recipe 579079 by Oscar Byrne (arguments, decorator, decorators, keyword, metadecorator, positional, python2, python3). Revision 2.

Python2.x implementation of python3's keyword-only arguments (aka arguments that must be specified as keywords, and are not automatically filled in by positional arguments - see PEP 3102).

Fluent API method decorator (Python)

2015-07-08T13:20:58-07:00

Python recipe 579078 by Oscar Byrne (api, decorator, decorators, fluent, interface).

A decorator for producing robust fluent API interfaces by returning a copy of self

Decorator to check method param types (Python)

2014-01-14T11:23:40-08:00

Python recipe 578809 by Andrey Nikishaev (decorators, method, typecheck).

This solution give possibility to check method param type, raise needed exception type, and also have good readability in the decorator definition.

Inherit method docstrings without breaking decorators or violating DRY (Python)

2013-07-01T02:29:40-07:00

Python recipe 578587 by nikratio (decorator, decorators, docstring, inheritance). Revision 2.

There are several recipes for inheriting method docstrings. However, most of them either violate DRY (and have you repeat the ancestor class name in the method decorator that sets the docstring), or do break decorators that try to access the docstring (because the docstring is only assigned after class creation). This recipe avoids both problems.

Note: This recipe uses the mro method from http://code.activestate.com/recipes/577748-calculate-the-mro-of-a-class/

Optional arguments decorator (Python)

2013-01-28T05:03:43-08:00

Python recipe 578435 by Maxime H Lapointe (class_decorator, decorator, decorators, python). Revision 2.

If you need your decorator to receive arguments, optional or not, then you should decorate it with the opt_arg_dec decorator to handle all the logic that this implies for you.

type Checking in Python using decorators (version 2.0) (Python)

2012-11-19T13:15:35-08:00

Python recipe 578330 by LL Snark (checking, debugging, decorators, type). Revision 2.

The two decorators checkparams and checkreturn allow you to check (at execution time) that function parameters or a function return value are the right type.

General decorators decorator (Python)

2012-11-13T09:44:07-08:00

Python recipe 578325 by Hans Zauber (decorators).

A general decorator aimed to decorate decorators, letting them keep (some of) the original attributes of the functions they decorate.

Cached Class (Python)

2012-01-06T02:24:08-08:00

Python recipe 577998 by Peter Donis (cache, decorators). Revision 5.

A class decorator that ensures that only one instance of the class exists for each distinct set of constructor arguments.

Note that if a decorated class is subclassed, each subclass is cached separately. (This is because each cached subclass is a different cls argument to the __new__ method.)

Indexable Generator (Python)

2012-01-03T06:10:18-08:00

Python recipe 578000 by Peter Donis (decorators, generators). Revision 4.

A decorator for generators that makes them indexable like a sequence.

Delayed Decorator (Python)

2011-12-20T06:37:15-08:00

Python recipe 577993 by Peter Donis (decorators).

This is a decorator wrapper class to delay decorating the base function until it is actually invoked. This can be useful when decorating ordinary functions if some decorator parameters depend on data that is only known at function invocation. It can also be used (and was written) to ensure that a decorated method of a class gets decorated once per instance instead of once per class; the use case that prompted this was the need to memoize a generator (see the Memoized Generator recipe), but the implementation is general.

Memoize Generator (Python)

2012-01-02T05:53:19-08:00

Python recipe 577992 by Peter Donis (decorators, generators, memoization, memoize). Revision 2.

A wrapper class for generators that "memoizes" them, so that even if the generator is realized multiple times, each term only gets computed once (after that the result is simply returned from a cache).

timeout decorator (with multiprocessing) (Python)

2011-08-23T05:25:09-07:00

Python recipe 577853 by matt harrison (decorator, decorators, multiprocessing, timeout).

Given that threads shouldn't be killed, multiprocessing is one mechanism for limiting time on a potentially long running computation.

Mixins by Inheritance vs. by Decorator...Let's Try Decorators (Python)

2011-08-12T15:29:21-07:00

Python recipe 577824 by Eric Snow (decorators, mixins).

Using mixin classes via inheritance has its pros and cons. Here is an easy alternative via a decorator. As a bonus, you can mix in attributes from any object, not just classes.

Apply decorators to all functions in a module (Python)

2011-06-09T22:51:28-07:00

Python recipe 577742 by Eric Snow (decorators, import, modules). Revision 2.

Use my modulehacker recipe (recipe 577740) to apply decorators to any number of modules, or even (nearly) all of them.

Turn @some_decorator() into @some_decorator (Python)

2011-08-04T18:48:36-07:00

Python recipe 577820 by Eric Snow (decorators).

A decorator factory is a function that returns a decorator based on the arguments you pass in. Sometimes you make a decorator factory to cover uncommon use cases. In that case you'll probably use default arguments to cover your common case.

The problem with this, however, is that you still have to use the call syntax (with no arguments) to get the common-use-case decorator, as demonstrated in the recipe title. This recipe effectively makes it so that your decorator factory and your common-use-case decorator have the same name (and actually the same object).

Inherit Method Docstrings Using Only Function Decorators (Python)

2011-06-26T02:28:55-07:00

Python recipe 577746 by Eric Snow (decorator, decorators, docstring). Revision 3.

This recipe provides a descriptor and a decorator. The decorator will be used on any method in your class to indicate that you want that method to inherit its docstring.

This is useful when you are using abstract bases classes and want a method to have the same docstring as the abstract method it implements.

This recipe uses recipe #577745, the deferred_binder module.

Lazy Dynamic Binding on Classes (You'll Never Go Back) (Python)

2011-08-12T23:42:27-07:00

Python recipe 577745 by Eric Snow (decorator, decorators, descriptor, descriptors). Revision 4.

This recipe provides a descriptor class and a decorator to make the deferred binding. Before the first access to that name, the __dict__ of the class will have the descriptor object. After that first access it will have whatever was returned by the first access.

One big advantage of deferring the binding is that the class object will be available at that time and can be passed to the object. During normal class creation the class body is exec'd before the class object is created, so the objects bound there can't be passed the class.

Recipe #577746 provides a concrete example of how the deferred_binder can be used.

Using Metaclasses and Class Decorators to Inherit Function Docstrings (Python)

2011-06-11T00:59:35-07:00

Python recipe 577743 by Eric Snow (decorator, decorators, docstring, inheritance, metaclass, metaclasses). Revision 4.

You'll find three different approaches to copying the method's docstring to the overriding method on a child class.

The function decorator approach is limited by the fact that you have to know the class when you call the decorator, so it can't be used inside a class body. However, recipe #577746 provides a function decorator that does not have this limitation.

Class decorator to check that methods are implemented. (Python)

2011-05-27T23:52:28-07:00

Python recipe 577725 by Jeffrey Fischer (decorators). Revision 2.

This decorator wraps the class's __init__ function to check that provided set of methods is present on the instantiated class. This is useful for avoiding inheritance in mix-in classes. We can inherit directly from object and still make it clear what methods we expect in other classes to be combined with the mix-in.

Requires at least Python 2.6, which added class decorators.

Trace decorator for debugging (Python)

2011-01-24T18:40:51-08:00

Python recipe 577551 by Kevin L. Sitze (classes, debug, debugging, decorators, functions, inspection, modules, trace). Revision 2.

This package provides a decorator for tracing function and method calls in your applications. The tracing capabilities are managed through the logging package, and several mechanisms are provided for controlling the destination of the trace output.

It also provides functionality for adding decorators to existing classes or modules.