Top-rated recipes tagged "decorator"

The goto decorator (Python)

2009-11-03T13:14:57-08:00

Python recipe 576944 by Carl Cerecke (bytecodes, decorator, goto). Revision 5.

A function-decorator that provides the goto command.

Probably the fastest memoization decorator in the world (Python)

2012-08-02T07:27:12-07:00

Python recipe 578231 by Oren Tirosh (cache, decorator, memo, memoization).

With apologies to a certain European brand of beer, this is probably the fastest memoization decorator in the world. Implemented using the __missing__ method in a dict subclass.

Humanize decorator (Python)

2013-07-31T16:04:13-07:00

Python recipe 578619 by tomer filiba (decorator, objects, pretty, print).

When you need to inspect Python objects in a human-readable way, you're usually required to implement a custom __str__ or __repr__ which are just boilerplate (e.g., return "Foo(%r, %r, %r)" % (self.bar, self.spam, self.eggs). You may implement __str__ and __repr__ by a base-class, but it's hard to call it inheritance and moreover, you may wish to remove it when you're done debugging.

This simple (yet complete) recipe is a class decorator that injects __str__ and __repr__ into the class being printed. It handles nesting and even cycle detection, allowing you to just plug it into existing classes to get them pretty-printed and perhaps remove it later.

Decorators for adding aliases to methods in a class (Python)

2011-04-16T19:29:35-07:00

Python recipe 577659 by José Nahuel Cuesta Luengo (alias, decorator).

The following recipe can be used as a means to adding aliases to methods in a class.

Asynchronous subprocess using asyncore (Python)

2013-01-21T19:51:00-08:00

Python recipe 576957 by Glenn Eychaner (async, asynchronous, asyncore, coroutine, decorator, generator, ipc, subprocess). Revision 21.

A coroutine-based wrapper for subprocess.Popen that uses asyncore to communicate with child processes asynchronously. This allows subprocesses to be called from within socket servers or clients without needing a complicated event loop to check both. Uses recipe 576965 to provide the asynchronous coroutine framework, recipe 576967 to provide asynchronous pipes, and recipe 577600 to provide multiple alarms.

Run async code inline, nonblocking (Python)

2009-11-11T12:55:01-08:00

Python recipe 576952 by Thomas Ahle (asynchronous, closure, decorator, generator, threads). Revision 7.

A decorator, that makes it easy to switch between the mainthread and background threads.

C function decorator (Python)

2009-04-29T23:55:03-07:00

Python recipe 576731 by geremy condra (cpp, ctypes, decorator, function). Revision 6.

This recipe provides an easy-to-use, decorator-based solution to the problem of using functions from other languages, especially C, in Python. It takes advantage of Python's new annotations to provide simple type checking and automatic conversion. If you like it, you may also want to check out my C structure decorator

Immutable class decorator (Python)

2012-08-05T08:30:41-07:00

Python recipe 578233 by Oren Tirosh (decorator, immutable).

Apply this decorator to a class with __slots__. Members will be mutable during the execution of __init__ but read-only afterwards.

partial with out of order arguments (Python)

2011-10-27T16:54:26-07:00

Python recipe 577922 by Przemyslaw Podczasi (decorator, partial). Revision 2.

Working with Windows API which usually takes like a zillion for each function can be a little bit frustrating and if I want to only change two in the middle for each call I had to wrap everything into lambda functions which change arguments to the order that I need to use with partial.

So finally I added kinda dangerous decorator which inserts keywords into right position if detected and was about to use it but ctypes functions don't accept keyword arguments :D so just ended up with decorator :)

Fast and elegant switch/case-like dispatch (Python)

2011-09-02T01:49:40-07:00

Python recipe 577864 by Jan Kaliszewski (case, decorator, dispatcher, performance, switch). Revision 4.

My approach to that common issue focuses on efficiency and elegant, declarative style of definition. That's why:

The way switches work is based on unwrapped defaultdict/list lookup.
The way you define switches is based on classes and easy-to-use decorators (note that you can use subclassing in a flexible way -- without any negative impact on efficiency!).
Its use cases focus on a-lot-of-keys situations and it does not cover the fall-through feature (though you can reach its semantics if you really need that -- by calling class methods...).

Deprecated decorator (Python)

2013-12-14T01:24:31-08:00

Python recipe 577819 by Giampaolo Rodolà (decorator, deprecated, python). Revision 3.

A decorator to deprecate a function and provide a new one as replacement.

Simple local cache and cache decorator (Python)

2010-12-08T09:06:34-08:00

Python recipe 577492 by Andrey Nikishaev (cache, decorator, memoization, python).

Simple local cache. It saves local data in singleton dictionary with convenient interface

Examples of use:

# Initialize
SimpleCache({'data':{'example':'example data'}})
# Getting instance
c = SimpleCache.getInstance()

c.set('re.reg_exp_compiled',re.compile(r'\W*'))
reg_exp = c.get('re.reg_exp_compiled',default=re.compile(r'\W*'))

# --------------------------------------------------------------

c = SimpleCache.getInstance()
reg_exp = c.getset('re.reg_exp_compiled',re.compile(r'\W*'))

# --------------------------------------------------------------    

@scache
def func1():
    return 'OK'

Pure Python implementation of PEP 380 (yield from) (Python)

2009-04-25T09:03:42-07:00

Python recipe 576727 by profjim (decorator, generators). Revision 7.

Decorator-based implementation of PEP 380 (yield from). This is the simple version (no special handling of nested "yield _from"s).

Method signature type checking decorator for Python 3 (Python)

2015-05-15T09:25:08-07:00

Python recipe 572161 by Dmitry Dvoinikov (checking, decorator, interface, method, signature, sysadmin, type). Revision 8.

This recipe allows nice and clean validation for method parameters/return values. It uses function annotations available in Python 3 for the actual signature specification.

Keyword-only arguments in Python 2.x (Python)

2015-09-22T18:16:40-07:00

Python recipe 578993 by Cara (arguments, decorator, keyword, keyword_only). Revision 10.

This is a decorator that makes some of a function's or method's arguments into keyword-only arguments. As much as it possible, it emulates the Python 3 handling of keyword-only arguments, including messages for TypeErrors. It's compatible with Python 3 so it can be used in code bases that support both versions.

Create and apply filters to lists of file paths (Python)

2012-03-20T21:17:26-07:00

Python recipe 578084 by eysi (blacklist, decorator, filter, walk, whitelist, yield). Revision 2.

An experiment with filtering lists of files, documentation is written directly into the code.

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.

Item Properties (Python)

2012-05-09T23:24:55-07:00

Python recipe 577703 by Ian Kelly (decorator, descriptor, oop, property). Revision 2.

A property variation that allows property access using an index or key.

Abstract method decorator (Python)

2011-04-20T21:50:23-07:00

Python recipe 577666 by jimmy2times (abstract, decorator, exception, inheritance, method, python, subclass). Revision 5.

A simple decorator that helps define abstract methods: when such a method is called, an appropriate exception is raised.

Keyword Argument Injection with Python Decorators (Python)

2010-09-05T17:06:04-07:00

Python recipe 577382 by Ahmet Emre Aladağ (class, class_decorator, decorator, injection, variable). Revision 2.

In most of the object oriented codes we write, we need to set class attributes to the given argument values and this is a very line-consuming thing. To get over these redundant lines, I found a solution using decorators.