Changeset 659 for branches

Timestamp:

04/06/13 13:23:59 (3 years ago)

Author:

mmckerns

Message:

added file_dict for dict with file backend; need to rethink "archive"

File:

• branches/decorate/memoize.py (modified) (3 diffs)

branches/decorate/memoize.py

@@ -114 +114 @@
 
 #FIXME: the below need expiration of cache due to time, calls, etc...
-#       and r/w to file or other caching mechanisms
 #FIXME: memoize*_round fails when decorating a class method
+#FIXME: need to ensure that all open's are closed appropriately
 
 # Want:
@@ -161 +161 @@
 
 
-'''
 class file_dict(archive_dict):
     """dictionary-style interface to a file"""
+    def __get_archive(self, archive):
+        try:
+            f = open(archive, 'rb')
+            import dill as pickle
+            cache = pickle.load(f)
+            f.close()
+        except:
+            cache = {}
+        return cache
     def __init__(self, filename=None, serialized=True): # False
         import os
         """filename = full filepath"""
         if filename is None:
-            if serialized: filename = 'memo.pkl'
-            else: filename = 'memo.py'
+            if serialized: filename = 'memo.pkl' #FIXME: need better default
+            else: filename = 'memo.py' #FIXME: need better default
         self._filename = filename
+        self._serialized = serialized
         if not os.path.exists(filename):
             if serialized: self.dump(filename)
             else: open(filename, 'wb').write('memo = {}')
         return
+    def __setitem__(self, key, value):
+        memo = self.__asdict__()
+        memo[key] = value
+        self.__save__(memo)
+        return
+    def __getitem__(self, key):
+        memo = self.__asdict__()
+        return memo[key]
+    def __asdict__(self):
+        if self._serialized:
+            memo = self.__get_archive(self._filename)
+        else:
+            import os
+            file = os.path.basename(self._filename)
+            root = os.path.realpath(self._filename).rstrip(file)[:-1]
+            curdir = os.path.realpath(os.curdir)
+            file = file.rstrip('.py') or file.rstrip('.pyc') \
+                or file.rstrip('.pyo') or file.rstrip('.pyd')
+            os.chdir(root)
+            exec 'from %s import memo' % file #FIXME: unsafe
+            os.chdir(curdir)
+        return memo
+    def has_key(self, key):
+        return key in self.__asdict__()
+    def get(self, key, value=None):
+        memo = self.__asdict__()
+        return memo.get(key, value)
+    def __save__(self, memo=None):
+        if memo == None: return
+        if self._serialized:
+            f = open(self._filename, 'wb')
+            import dill as pickle
+            pickle.dump(memo, f)
+        else:
+            open(self._filename, 'wb').write('memo = %s' % memo)
+        return
+    def pop(self, key, *value):
+        memo = self.__asdict__()
+        res = memo.pop(key, *value)
+        self.__save__(memo)
+        return res
+    def clear(self):
+        self.__save__({})
+        return
+    def update(self, adict, **kwds):
+        memo = self.__asdict__()
+        memo.update(adict, **kwds)
+        self.__save__(memo)
+        return
+    def itervalues(self):
+        return self.__asdict__().itervalues()
+    def values(self):
+        return list(self.itervalues())
+    def iteritems(self):
+        return self.__asdict__().iteritems()
+    def items(self):
+        return list(self.iteritems())
+    def keys(self):
+        return list(self.__iter__())
+    def __repr__(self):
+        return "memo(%s)" % self.__asdict__()
+    def __iter__(self):
+        return self.__asdict__().iterkeys()
+    iterkeys = __iter__
     pass
-'''
 
 
@@ -319 +391 @@
     Can memoize a *method* on an object.
     """
-    def __init__(self, func): #memo=None, serializer=str):
+    def __init__(self, memo=None, serializer=str, tol=None, deep=False):
+#     self.func = func
+      if memo is None: memo = archive_dict()
+      elif type(memo) is dict: memo = archive_dict(memo)
+      self.memo = memo
+      self.__serializer = serializer
+
+      if deep: rounded = deep_round
+      else: rounded = simple_round
+
+      @rounded(tol)
+      def rounded_args(*args, **kwds):
+          return (args, kwds)
+      self.__rounded_args = rounded_args
+      return
+
+    def __call__(self, func):
       self.func = func
-     #if memo is None: memo = dict()
-      self.memo = {} #memo
-      import cPickle as pickle
-      self.serializer = pickle.dumps #serializer
-
-    def __call__(self, *args, **kwds):
-      try:
-        argstr = self.serializer((args, kwds))
-        if self.memo.has_key(argstr):
-          return self.memo[argstr]
-        res = self.func(*args, **kwds)
-        self.memo[argstr] = res
-        return res
-      except: #TypeError
-        return self.func(*args, **kwds)
+      import functools
+      @functools.wraps(func)
+      def dec(*args, **kwds):
+        try:
+          _args, _kwds = self.__rounded_args(*args, **kwds)
+          argstr = self.__serializer((_args, _kwds))
+          if self.memo.has_key(argstr):
+            return self.memo[argstr]
+          res = self.func(*args, **kwds)
+          self.memo[argstr] = res
+          return res
+        except: #TypeError
+          return self.func(*args, **kwds)
+      return dec
 
     def __repr__(self):