#!/usr/bin/env python
from __future__ import division

import os, os.path
import cPickle as pickle
from functools import wraps
from time import time

from hashlib import md5
from itertools import chain

class memoized(object):
    """Decorator that caches a function's return value each time it is called.
    If called later with the same arguments, the cached value is returned, and
    not re-evaluated.
    """
    def __init__(self, func):
        self.func = func
        self.cache = {}
    def __call__(self, *args):
        try:
            return self.cache[args]
        except KeyError:
            value = self.func(*args)
            self.cache[args] = value
            return value
        except TypeError:
            # uncachable -- for instance, passing a list as an argument.
            # Better to not cache than to blow up entirely.
            return self.func(*args)
    def __repr__(self):
        """Return the function's docstring."""
        return self.func.__doc__
    def __get__(self, obj, objtype):
        """Support instance methods."""
        fn = functools.partial(self.__call__, obj)
        fn.reset = self._reset
        fn.getcache = self._get_cache
        fn.setcache = self._set_cache
        fn.cachedict = self._get_cache_dict
        return fn
        
    def _reset(self):
        self.cache = {}
    def _get_cache(self,key):
        return self.cache[key]
    def _set_cache(self,key,value):
        self.cache[key] = value
    def _get_cache_dict(self):
        return self.cache