from __future__ import with_statement
import time
import threading
+import pickle
from datetime import datetime
# maximum lifetime of cached data (in seconds)
def get_data(self):
return self.data
+
+ def dump(self):
+ return self.__dict__
+
+ def __str__(self):
+ return str(self.dump())
+
+ def tostring(self):
+ return self.__str__()
+
+ def __getstate__(self):
+ d = dict(self.__dict__)
+ del d['lock']
+ return d
+
+ def __setstate__(self, d):
+ self.__dict__.update(d)
+ self.lock = threading.RLock()
+
+
class Cache:
cache = {}
lock = threading.RLock()
+
+ def __init__(self, filename=None):
+ if filename:
+ self.load_from_file(filename)
def add(self, key, value, ttl = MAX_CACHE_TTL):
with self.lock:
def get(self, key):
data = self.cache.get(key)
- if not data or data.is_expired():
- return None
- return data.get_data()
+ if not data:
+ data = None
+ elif data.is_expired():
+ self.pop(key)
+ data = None
+ else:
+ data = data.get_data()
+ return data
+
+ def pop(self, key):
+ if key in self.cache:
+ self.cache.pop(key)
+
+ def dump(self):
+ result = {}
+ for key in self.cache:
+ result[key] = self.cache[key].__getstate__()
+ return result
+
+ def __str__(self):
+ return str(self.dump())
+
+ def tostring(self):
+ return self.__str()
+
+ def save_to_file(self, filename):
+ f = open(filename, 'w')
+ pickle.dump(self.cache, f)
+
+ def load_from_file(self, filename):
+ f = open(filename, 'r')
+ self.cache = pickle.load(f)