~ubuntu-branches/debian/sid/python-decorator/sid

from the cache and not recomputed. There are many implementations of 

``memoize`` in http://www.python.org/moin/PythonDecoratorLibrary, 

but they do not preserve the signature.

that in general it is impossible to memoize correctly something

that depends on non-hashable arguments):

 

 

Here we used the functools.update_wrapper_ utility, which has

been added in Python 2.5 expressly to simplify the definition of decorators

The implementation above works in the sense that the decorator 

can accept functions with generic signatures; unfortunately this

implementation does *not* define a signature-preserving decorator, since in

*different signature* from the original function.

 

Consider for instance the following case:

 

.. code-block:: python

 

 ... def f1(x):

 ...     time.sleep(1) # simulate some long computation

 ...     return x

.. code-block:: python

 

 >>> from inspect import getargspec 

 

This means that introspection tools such as pydoc will give

wrong informations about the signature of ``f1``. This is pretty bad:

 

$$memoize

 

on nested functions, is that the decorator module forces you to lift

the inner function at the outer level (*flat is better than nested*).

Moreover, you are forced to pass explicitly the function you want to

.. code-block:: python

 

 >>> print getargspec(heavy_computation) 

 

A ``trace`` decorator

------------------------------------------------------

.. code-block:: python

 

 >>> print getargspec(f1) 

 

The same decorator works with functions of any signature:

 

 calling f with args (0, 3, 2), {}

 

 >>> print getargspec(f) 

 

That includes even functions with exotic signatures like the following:

 

 ... def exotic_signature((x, y)=(1,2)): return x+y

 

 >>> print getargspec(exotic_signature)

 >>> exotic_signature() 

 calling exotic_signature with args ((1, 2),), {}

 3

``decorator`` module provides a poor man replacement for

``functools.partial``.

 

``blocking``

-------------------------------------------

 

Each call to ``write`` will create a new writer thread, but there will 

be no synchronization problems since ``write`` is locked.

 

 

The ``FunctionMaker`` class

---------------------------------------------------------------

Compatibility notes

---------------------------------------------------------------

 

 

Finally ``decorator`` cannot be used as a class decorator and the

`functionality introduced in version 2.3`_ has been removed. That

means that in order to define decorator factories with classes you

need to define the ``__call__`` method explicitly (no magic anymore).

All these changes should not cause any trouble, since they were

all rarely used features. Should you have any trouble, you can always

downgrade to the 2.3 version.

 

is also supported - of course the examples requiring the ``with``

you will notice a few differences since

``getargspec`` returns an ``ArgSpec`` namedtuple instead of a regular

tuple. That means that running the file

 

.. _functionality introduced in version 2.3: http://www.phyast.pitt.edu/~micheles/python/documentation.html#class-decorators-and-decorator-factories

.. _function annotations: http://www.python.org/dev/peps/pep-3107/

 

LICENCE

---------------------------------------------

 

__doc__ = __doc__.replace('$VERSION', VERSION).replace('$DATE', today)

 

def decorator_apply(dec, func):

    """

    Decorate a function by preserving the signature even if dec 

@identity_dec

def example(): pass

 

    func.cache = {}

    def memoize(*args, **kw):

        if kw: # frozenset is used to ensure hashability

def memoize(f):

    f.cache = {}

    return decorator(_memoize, f)

 

class User(object):

    "Will just be able to see a page"

class PermissionError(Exception):

    pass

 

 

class Action(object):

    """

    if n == 0: return 1

    return n * fact(n-1)

 

    """

    In version 3.1.0 decorator(caller) returned a nameless partial

    object, thus breaking Pylons. That must not happen again.

    >>> decorator(_memoize).__name__

    '_memoize'

 

 

    """

 

if __name__ == '__main__':