Popular recipes tagged "decorator" but not "closure"

Function guards for Python 3 (Python)

2016-05-01T13:11:05-07:00

Python recipe 580658 by Dmitry Dvoinikov (call, decorator, dispatch, function, guard).

This module implements a function guard - facility to redirect the the call to one of several function implementations at run time based on the actual call arguments.

Wrap each of the identically named functions in a @guard decorator and provide a _when parameter with a default value set to guarding expression.

See samples at the top of the module.

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

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.

Decorator to check if needed modules for method are imported (Python)

2014-03-18T14:11:20-07:00

Python recipe 578852 by Andrey Nikishaev (decorator, import).

Check if needed modules imported before run method

Example::

    @require_module(['time'],exception=Exception)
    def get_time():
        return time.time()

More strict unittests using a validator (Python)

2014-03-01T12:37:47-08:00

Python recipe 578793 by Thomas Lehmann (decorator, unittests, validator). Revision 4.

The main point is that there was no binding between a unit tests and the concrete class. It did happend often that you are indirectly testing a class using it also the concrete test class has missed some concrete test methods. I found this fact sometimes very irritating seeing 100% coverage.

Therefor I now provide this class decorator where you can specify the class that will be tested. If you do not specify test methods for each method of the testable class an exception will be thrown providing a list of missed tests.

Here some examples how it works: You implemented a

method "__eq__", then write a "testEqual" method
method "__init__", then write a testInit" method
method "scalar_product", then write a testScalarProduct" method
and so on ...

The way to use this class decorator you can see in the doctest area (see below in the code) The only point to be aware of is that when you use the decorator you have to implement all test to get rid of the thrown execption. Of course you can implement more tests for same class.

New in revision 4 (1st march 2014):

Bugfix: the algorithm were not correctly detecting which methods were really overwritten forcing to implement tests for methods which were base class only.
Bugfix: decorated classes which contain the attribute "decorated_object" can be handled properly.
A new second parameter now allows you to implement several classes in same test class forcing you to include the class name in the test method:
- @ValidateTestResponsibilityFor(Square, True)
- @ValidateTestResponsibilityFor(Sin, True)
- => testSquareInit, testSquareGet, testSinInit, testSinGet, ...
- This for smaller classes to avoid too many files (at least ... you decided)

language decorator (Python)

2013-10-02T08:00:29-07:00

Python recipe 578677 by Dr. Trigon (decorator, embedded_language).

Use other languages like lua, C++ or simple bash from python. Instead of writing code as a string and then send it to some eval or execute function, we introduce here decorators that allow to write regular python functions containing the external code as docstring.

That way the external code needs minimal adoptions only and becomes better read- and maintainable. Write your function in your favourite language and just place the right decorator in front of it - it simple like that.

At the current state this recipe is a DRAFT and needs to be further extended and tested.

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.

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/

deprecate decorator which accepts arguments (Python)

2013-08-23T13:24:40-07:00

Python recipe 578650 by tlatsas (decorator, deprecated). Revision 2.

The deprecate decorator can be used to warn for future or current code deprecations. It accepts a message and an optional Warning class which will be passed to the warnings.warn() function.

Type checking using Python 3.x annotations (Python)

2013-05-23T22:46:19-07:00

Python recipe 578528 by David Mertz (annotations, check, decorator, python3, type, typecheck). Revision 5.

Some other recipes have been suggested to allow type checking by various means. Some of these require the use of type specification in a decorator itself. Others try to be much more elaborate in processing a large variety of annotations (but hence require much more and more convoluted code).

The recipe provided below is very short, and simply provides actual type checking of arguments and return values. It utilizes an unadorned decorator, rather than manufacture one that is parameterized by types or other arguments.

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.

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.

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.

Recipe With No Name Yet (Python)

2012-08-22T17:57:12-07:00

Python recipe 578221 by Cyril (check, debug, decorator, wrapper). Revision 9.

Not a very new recipe, but a short one and (I hope) useful :

wrapping any function "f" with two decorators "enter_event" and "exit_event" that will trigger calling of user functions when, ... hum ... evidently, just before entering and just after exiting the "f" function.

Typical usages :

debugging on a function by function basis :
- emit a trace in log file to see when functions are called and check sequences correctness (very usefull when programming by events)
- feed a profile analyzer (by fine tuning which functions are enabled)
- feed a code coverage analyzer ( " )
kind of validator on function calling :
- implement programming by contracts :
  - check that parameters values of "f" function will not have an unexpected value or be of an unexpected type
  - this allow to increase code robustness by narrowing
- implement invariants (eg. check that returned value is always in the excepted range, ...)
- insure that a function follow specifications by meta-checking that has always predictable results (eg. return the fixed expected value for each possible input value, ...)
minimum modification of existing code
in the same thinking line as the "monkey patching" concept

Notes on usage :

recipe works on functions and any kind of methods (methods, class methods, and static methods)
the usage order of "@enter_event" and "@exit_event" decorators doesn't matter : the result will be the same

PLEASE VOTE FOR THIS RECIPE if you like it !

Recursively defined, Haskell-style infinite lists (Python)

2012-05-04T14:09:14-07:00

Python recipe 578119 by John Crichton (decorator, functional, generator, infinite, itertools, lazy, recursive). Revision 2.

A decorator to simplify the creation of recursively defined, Haskell-style infinite lists -- ie. recursive generators -- inspired by Raymond Hettinger's "Technique for cyclical iteration" [*].

[*] http://code.activestate.com/recipes/576961-technique-for-cyclical-iteration/

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.

Dynamic function parameters using annotations (Python)

2012-02-22T22:31:02-08:00

Python recipe 578049 by pavel (annotations, decorator).

Python default values for keyword arguments are evaluated only once and not on every function call. For example following function will not work as user may expect:

def printNow(l=[], now=datetime.now()):
    l.append(len(l))

    print('List:', l, ' id:', id(l))
    print('Now:', now)


for i in range(3):
    printNow()
    print()

The "dynamic" decorator solves problem by evaluating callables, that are assigned to parameters using annotations syntax (see PEP 3107).

RPDB (RobotPythonDebugger) -- a smarter way to debug robotframework tests (Python)

2012-03-14T15:12:39-07:00

Python recipe 578073 by Daniel Cohn (debugging, decorator, pdb, redirect, robot, rpdb, stdin, stdout).

Robotframework (http://code.google.com/p/robotframework/) is a tool used to run functional tests against a variety of targets. Tests are organized in the form of keyword tsv or html files, which map input parameters to keyword-argument methods in the test suite. Robot includes a fairly advanced logging mechanism, which is cool -- until you try to debug anything. Debugging is made difficult because robot steals stdin and stdout when it is run, which means bye-bye debugging in the terminal. rpdb solves this in a KISS simple way.

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 :)