Changeset 590 for branches

Timestamp:

11/13/12 19:10:10 (4 years ago)

Author:

mmckerns

Message:

added reading and writing to disk archive for memoize

Location:

branches/decorate

Files:

• memoize.py (modified) (2 diffs)
• test_cached_memoize.py (added)

branches/decorate/memoize.py

@@ -50 +50 @@
 
 
+def get_archive(archive):
+    import dill as pickle
+    try:
+        f = open(archive, 'rb')
+        cache = pickle.load(f)
+        f.close()
+    except:
+        cache = {}
+    return cache
+
+
+def load_factory(memo=None):
+    if memo is None: memo = {}
+    def load(archive=None, *args):
+        cache = get_archive(archive)
+        if not args:
+            memo.update(cache)
+        for arg in args:
+            if cache.has_key(arg):
+                memo.update({arg:cache[arg]})
+        cache.clear()
+        return
+    return load
+
+
+def dump_factory(memo=None):
+    if memo is None: memo = {}
+    import dill as pickle
+    def dump(archive=None, *args):
+        cache = get_archive(archive)
+        for arg in args:
+            if memo.has_key(arg):
+                cache.update({arg:memo[arg]})
+        if not args:
+            cache.update(memo)
+        try:
+            f = open(archive, 'wb')
+            pickle.dump(cache, f)
+        except:
+            pass  #XXX: warning? fail?
+        cache.clear()
+        return
+    return dump
+
+
 #FIXME: the below need expiration of cache due to time, calls, etc...
 #       and potentially r/w to database, file, or other caching mechanism
 #FIXME: memoize*_round fails when decorating a class method
 
+#FIXME: resolve signature difference...  @memoized versus @memoized()
 
 def memoized0_nopickle_round(tol=0):
@@ -110 +156 @@
                 return f(*args, **kwds)
         func.memo = memo
+        return func
+    return dec
+
+
+
+# Want:
+# - if has archive, then can try reading archive if not found in memory
+# - if has archive, then can write to archive upon evaluation
+# - load an archive / update an existing archive
+# - save some or all of memo to archive
+def memoized0_nopickle_archived():
+    """Decorator that memoizes a function's return value each time it is called.
+    If called later with the same arguments, the memoized value is returned, and
+    not re-evaluated.  This may lead to memory issues, as memo is never cleared.
+    This decorator takes an integer tolerance 'tol', equal to the number of
+    decimal places to which it will round off floats.
+    """
+    memo = {}
+    load = load_factory(memo)
+    dump = dump_factory(memo)
+
+    def dec(f):
+        def func(*args, **kwds):
+            try:
+                argstr = str((args, kwds))
+                if not memo.has_key(argstr):
+                    load(argstr)
+                if not memo.has_key(argstr):
+                    memo[argstr] = f(*args, **kwds)
+                return memo[argstr]
+            except: #TypeError
+                return f(*args, **kwds)
+        func.memo = memo
+        func.load = load
+        func.dump = dump
+        return func
+    return dec
+
+
+def memoized0_archived():
+    """Decorator that memoizes a function's return value each time it is called.
+    If called later with the same arguments, the memoized value is returned, and
+    not re-evaluated.  This may lead to memory issues, as memo is never cleared.
+    This decorator takes an integer tolerance 'tol', equal to the number of
+    decimal places to which it will round off floats.
+    """
+    memo = {}
+    load = load_factory(memo)
+    dump = dump_factory(memo)
+
+    def dec(f):
+        def func(*args, **kwds):
+            try:
+               #import cPickle as pickle
+                import dill as pickle
+                argstr = pickle.dumps((args, kwds))
+                if not memo.has_key(argstr):
+                    load(argstr)
+                if not memo.has_key(argstr):
+                    memo[argstr] = f(*args, **kwds)
+                return memo[argstr]  #XXX: any automated dump to archive?
+            except: #TypeError
+                return f(*args, **kwds)
+        func.memo = memo
+        func.load = load  #XXX: only use with no arguments?
+        func.dump = dump  #XXX: only use with no arguments?
         return func
     return dec