Changeset 655 for branches

Timestamp:

04/04/13 16:28:27 (3 years ago)

Author:

mmckerns

Message:

abstracted serializer and memo in memoize.memoized; added db_memo

Location:

branches/decorate

Files:

• memoize.py (modified) (2 diffs)
• test_memoize.py (modified) (1 diff)

branches/decorate/memoize.py

@@ -283 +283 @@
 
 
-def memoized():
-    """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.
-    """
-    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):
-                    memo[argstr] = f(*args, **kwds)
-                return memo[argstr]
+#XXX: should inherit from object not dict ?
+class db_dict(dict): #XXX: requires UTF-8 key
+    """decorator that can memoize to a database (API mimics a dict)
+    """
+    def __init__(self, database=None, table=None):
+        """database = database url; table = table name"""
+        if database == None: database = ':memory:'
+        self._database = database
+        if table == None: table = 'memo'
+        self._table = table
+        import sqlite3 as db
+        self._conn = db.connect(database)
+        self._curs = self._conn.cursor()
+        sql = "create table %s(argstr, fval)" % table
+        self._curs.execute(sql)
+        return
+    def __setitem__(self, key, value): #XXX: maintains 'history' of values
+        sql = "insert into %s values(?,?)" % self._table
+        self._curs.execute(sql, (key,value))
+        self._conn.commit()
+        return
+    def __getitem__(self, key):
+        sql = "select * from %s where argstr = ?" % self._table
+        res = tuple(self._curs.execute(sql, (key,)))
+        if res: return res[-1][-1] # always get the last one
+        raise KeyError, key
+    def __asdict__(self):
+        sql = "select * from %s" % self._table
+        res = self._curs.execute(sql)
+        d = {}
+        [d.update({k:v}) for (k,v) in res] # always get the last one
+        return d
+    def has_key(self, key):
+        return key in self.keys()
+    def get(self, key, value):
+        return self.__asdict__().get(key, value)
+    def items(self):
+        return self.__asdict__().items()
+    def keys(self):
+        return self.__asdict__().keys()
+    def values(self):
+        return self.__asdict__().values()
+    def __repr__(self):
+        return "memo(%s)" % self.__asdict__()
+    pass
+
+
+def memoized(memo=None, serializer=str):
+    """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.
+
+    memo = storage hashmap (default is {})
+    serializer = serializing function (e.g. pickle.dumps, but default is str)
+    """
+    if memo == None: memo = dict()
+
+    def dec(f):
+        def func(*args, **kwds):
+            try:
+                argstr = serializer((args, kwds))
+                if memo.has_key(argstr):
+                    return memo[argstr]
+                res = f(*args, **kwds)
+                memo[argstr] = res
+                return res
             except: #TypeError
                 return f(*args, **kwds)
@@ -311 +361 @@
     not re-evaluated.  This may lead to memory issues, as memo is never cleared.
     """
-    def __init__(self, func):
+    def __init__(self, func): #memo=None, serializer=str):
       self.func = func
-      self.memo = {}
+     #if memo == None: memo = dict()
+      self.memo = {} #memo
+      import cPickle as pickle
+      self.serializer = pickle.dumps #serializer
 
     def __call__(self, *args, **kwds):
       try:
-         #import cPickle as pickle
-          import cPickle as pickle
-          argstr = pickle.dumps((args, kwds))
-          if not self.memo.has_key(argstr):
-              self.memo[argstr] = self.func(*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 self.func(*args, **kwds)
 
     def __repr__(self):

branches/decorate/test_memoize.py

@@ -109 +109 @@
 print costD([1,2,3.1234], 3.6789)
 print costD([1,2,3.4321], 3.6789)
+print ""
+
+
+from memoize import memoized
+from memoize import db_dict 
+import dill as pickle
+@memoized(memo=db_dict())
+def add(x,y):
+    return x+y
+add(1,2)
+add(1,2)
+add(1,3)
+print "db_memo = %s" % add.memo
+
+@memoized(memo=dict())
+def add(x,y):
+    return x+y
+add(1,2)
+add(1,2)
+add(1,3)
+print "dict_memo = %s" % add.memo
+
+@memoized(memo=add.memo)
+def add(x,y):
+    return x+y
+add(1,2)
+add(2,2)
+print "re_dict_memo = %s" % add.memo
+
+@memoized(serializer=pickle.dumps)
+def add(x,y):
+    return x+y
+add(1,2)
+add(1,2)
+add(1,3)
+print "pickle_dict_memo = %s" % add.memo