Cache the result of a function for certain time.

cache.py

from time import monotonic
from functools import wraps

def cache(expiration_s):
    """
    Cache the result of a function for certain time.

    There is one restriction: all arguments of the wrapped function must be
    immutable, that is, they must be used as key in a dictionary.

    Usage::

        from time import time

        @cache(10.0)
        def foo(ham, jam):
            return time()

    The above will cache the value returned by the function for 10 seconds for
    specific values for `ham` and `jam`.

    :param float expiration_s: Time in second for how long the cache is valid.

    :return: a decorator.
    :rtype: function
    """
    cache = {}

    def decorator(function):

        @wraps(function)
        def replacement(*args, **kwargs):

            # Determine unique signature for the call
            signature = tuple(args) + tuple(sorted(
                ((name, value) for name, value in kwargs.items()),
                key=lambda e: e[0],
            ))

            # Fetch the cache and check if still valid
            when, cached = cache.get(signature, (None, None))
            now = monotonic()

            if when is not None and (now - when) < expiration_s:
                return cached

            # Call function and save the result into the cache
            new = function(*args, **kwargs)
            cache[signature] = (now, new)

            return new

        return replacement

    return decorator


__all__ = [
    'cache',
]