Popular Python recipes tagged "meta:requires=new"

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.

Composition of classes instead of multiple inheritance (Python)

2011-04-16T03:40:19-07:00

Python recipe 577658 by Ethan Furman (class_decorator, composition, inheritance, multiple_inheritance).

MI can be difficult and confusing, and if the base classes don't cooperate -- well, cooperative MI won't work.

One way around this is to use composition instead. This class decorator will combine the source classes with the target class, ensuring that no duplications occur (raises a TypeError if there are any).

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.

Decoupled Proxy of a State Bearing Object in a Multiprocessing Environment (Python)

2010-04-08T04:36:05-07:00

Python recipe 577180 by Mateyuzo (access, multiprocessing, process, processing, subprocess, synchronization, syncmanager, threading, __getattribute__). Revision 2.

Describes a simple example of the potential for shared Singleton or Borg object methods to be proxy'd by an object that SyncManger can present to requesting subprocesses.

Basic class code generator (Python)

2010-03-22T10:58:19-07:00

Python recipe 577130 by Mateyuzo (generator, prototyping, template). Revision 5.

This little script takes a yaml file as a class definition and generates code stubs and unit tests.

SuperFly: Separating class heirarchy from class definition. (Python)

2009-02-15T20:47:51-08:00

Python recipe 576652 by Ted Skolnick (inheritance, polymorphism). Revision 2.

This is a recipe for defining class hierarchies outside of class definitions. This way you could at, runtime, decide what class should act as the parent of a given class. A class could sometimes have one parent, sometimes another.

Simple shelve with Linux file locking (Python)

2008-12-21T05:50:07-08:00

Python recipe 576591 by Michael Ihde (dynamic_method, locking, shelve).

The shelve module is a easy way to add persistence to your application via a DBM database. However, if you have multiple reader/writer combination you need to lock the file to prevent corruption. The shelve module itself does not provide locking because it is platform specific. If you only need Linux, this simple module provide an easy way to support locking using dynamically added methods.

Pickle the interactive interpreter state (Python)

2008-05-20T10:36:50-07:00

Python recipe 572213 by Oren Tirosh (sysadmin). Revision 2.

This code extends the pickle module to enable pickling of functions and classes defined interactively at the command prompt. You can save the interpreter state by pickling the __main__ module and restore it later.

Copying Generators (Python)

2007-10-09T07:38:06-07:00

Python recipe 528949 by kay schluehr (algorithms). Revision 5.

This recipe presents copy_generator(...) which a pure Python function keeping a running generator object and returns a copy of the generator object being in the same state as the original generator object.

True Lieberman-style delegation in Python. (Python)

2007-05-14T11:14:33-07:00

Python recipe 519639 by Martin Blais (algorithms).

Proxies are usually implemented as objects that forward method calls to a "target" object. This approach has a major problem: forwarding makes the target object the receiver of the method call; this means that calls originating from the body of a method in the target will not go through the proxy (and thus their behavior cannot be modified by the proxy).

For example, suppose we want a proxy to an instance of Target (shown below) that is "safe", i.e., does not do anything bad like firing missiles. We can just define a class that forwards calls to the safe methods, namely send_flowers() and hang_out(). This class can have its own version of fire_missiles() that does nothing. Now consider what happens when we call the proxy object's innocent-looking hang_out() method. The call is forwarded to the target object, which in turn calls the target object's (not the proxy's) fire_missiles() method, and BOOM! (The proxy's version of fire_missiles() is not called because forwarding has made the target object the receiver of the new method call.)

By using delegation, one can implement proxies without the drawbacks of the method-forwarding approach. This recipe shows how Python's __getattr__ method can be used to implement the kind of delegation present in prototype-based languages like Self and Javascript, and how delegation can be used to implement better proxies.

Implementing the make statement by hacking bytecodes (Python)

2008-12-31T09:47:48-08:00

Python recipe 498242 by Nilton Volpato (programs). Revision 4.

The make statement from PEP 359 is implemented using decorators and function definitions.

The make statement:

make <callable> <name> <tuple>:
    <block>

is implemented this way:

@make(<callable>, <tuple>)
def <name>():
    <block>

The code also has some examples, using the make decorator to create a namespace and a class.

Extract a inner function from a class or a function (Python)

2006-06-19T22:03:22-07:00

Python recipe 496806 by Sunjoong LEE (debugging). Revision 2.

This function can extract a inner function from a class or a function. It may be useful when writing a unit test code.

Changing a closed-over value (in a "cell") (Python)

2005-09-02T18:40:43-07:00

Python recipe 440515 by paul cannon (debugging).

In most languages with closures, it is possible to change a closed-over value and have the change visible in other closures which share a reference to the same variable. Python's syntax makes this impossible.

Even if you're content (I am) with the work-around-- putting your changeable values inside a mutable object like a list-- it may occasionally happen that you wish you could change the closed-over values, found in "cell" objects in a function's func_closure tuple. Another recipe I submitted shows how to get at the values in standard Python; this one will demonstrate a way to actually change that value, so that functions which also close over that value (share a reference to the same cell) will see the change.

Thread-safe caching object with file and HTTP implementations (Python)

2006-02-08T10:04:16-08:00

Python recipe 302997 by Nicolas Lehuen (algorithms). Revision 9.

Implementation of an abstract, thread-safe cache with minimal locking. Four concrete implementations : a validating file cache, a validating HTTP cache, an experimental Python module cache and a function cache. Plus, an abstract cache with weak references to its values.

A meta-class that provides class behavior like Ruby (Python)

2004-12-29T19:37:12-08:00

Python recipe 361167 by Ikkei Shimomura (oop).

It brings Ruby-like class behavior. When a class is declared, it extends the old class if the class name exists already.

mixins for proxy construction... (Python)

2004-09-18T20:54:37-07:00

Python recipe 305308 by Alex Naanou (oop). Revision 2.

Here we will demonstrate a technique that will make it possible to semi-transparently proxy an object and override/proxy methods or data including special methods like __call__. this module will define several general tools and components that can be used as a basis for creation of various proxy classes...

high-performance currying with instancemethod (Python)

2003-10-17T15:57:11-07:00

Python recipe 229472 by Alex Martelli (algorithms).

instancemethod provides a way to perform currying such that the curried function runs much faster than one produced by closure (the second-fastest way). [Currying is explained and covered in detail in other recipes]

co_pickle , a module to serialize code objects (Python)

2003-07-27T07:10:50-07:00

Python recipe 212565 by Andres Tremols (shortcuts).

Compiles a string of python code and returns a printable representation of the byte codes, the resulting string can then be restored back to a code object.

Dynamic Classes (Python)

2003-05-22T15:24:23-07:00

Python recipe 201294 by Bud P. Bruegger .

some simple functions for dynamically adding methods, properties,and classmethods to classes at runtime

Allowing the Python profiler to profile C modules (Python)

2001-10-14T09:01:29-07:00

Python recipe 81535 by Richie Hindle (debugging). Revision 3.

This recipe lets you take into account time spent in C modules when profiling your Python code. Normally the profiler only profiles Python code, so finding out how much time is spent accessing a database, running encryption code, sleeping and so on is difficult. Profilewrap makes it easy to profile C code as well as Python code, giving you a clearer picture of where your application is spending its time.

Profilewrap demonstrates how to create proxy objects at runtime that intercept calls between pre-existing pieces of code. It also demonstrates the use of the 'new' module to create new functions on the fly.