Reports - user usefullness

sitescripts/utils.py

 # coding: utf-8
 
 # This Source Code is subject to the terms of the Mozilla Public License
 # version 2.0 (the "License"). You can obtain a copy of the License at
 # http://mozilla.org/MPL/2.0/.
 
 import os, sys, codecs, subprocess, sitescripts
 from time import time
 from tempfile import mkstemp
 from ConfigParser import SafeConfigParser
 
 siteScriptsPath = sitescripts.__path__[0]
 
-class memoize:
-  """
-    Decorator that caches a function with arguments return value.
-  """

[Wladimir Palant, 2012/10/22 13:32:52]

Any reason to introduce a new decorator instead of making cached below consider
arguments properly?

Note that storing values for an unlimited amount of time is generally not
useful, you have no idea how long this process will stay around.

[Andrey Novikov, 2012/10/23 14:15:29]

I thought you were not considering them on purpose.

-  def __init__ (self, f):
-    self.f = f
-    self.mem = {}
-
-  def __call__ (self, *args, **kwargs):
-    if (args, str(kwargs)) in self.mem:

[Wladimir Palant, 2012/10/22 13:32:52]

How about calculating str(kwargs) once at the beginning of the function? Also,
maybe note somewhere that this approach will only work for simple parameter
types.

[Andrey Novikov, 2012/10/23 14:15:29]

Done.

-      return self.mem[args, str(kwargs)]
-    else:
-      tmp = self.f(*args, **kwargs)
-      self.mem[args, str(kwargs)] = tmp
-      return tmp
-
 class cached(object):
   """
     Decorator that caches a function's return value for a given number of seconds.
-    Note that this can only be used with functions that take no arguments.
+    Note that this only works if the string representation of the parameters is
+    always unique.
   """
-
   def __init__(self, timeout):
     self.timeout = timeout
-    self.func = None
-    self.lastUpdate = None
-    self.lastResult = None
+    self.lastResult = {}
+    self.lastUpdate = {}
 
-  def __call__(self, *args):
-    if len(args) == 1:
-      # We got called with the function to be decorated - remember the function
-      # and return the same object again
-      self.func = args[0]
-      return self
-    else:
+  def __call__(self, func):
+    def wrapped(*args, **kwargs):
+      key = str(kwargs)
       currentTime = time()
-      if self.lastUpdate == None or currentTime - self.lastUpdate > self.timeout:
-        self.lastResult = self.func()
-        self.lastUpdate = currentTime
-      return self.lastResult
+      if (args, key) not in self.lastUpdate or currentTime - self.lastUpdate[args, key] > self.timeout:
+        self.lastResult[args, key] = func(*args, **kwargs)
+        self.lastUpdate[args, key] = currentTime
+      return self.lastResult[args, key]
+    self.func = func
+    return wrapped
 
   def __repr__(self):
-    """Return the function's docstring"""
-    return self.func.__doc__
+    return repr(self.func)
 
 @cached(3600)
 def get_config():
   """
     Returns parsed configuration file (SafeConfigParser instance). File paths
     that will be checked: ~/.sitescripts, ~/sitescripts.ini, /etc/sitescripts,
     /etc/sitescripts.ini
   """
 
   paths = []
@@ skipping 69 matching lines @@
 def get_unescaped_template_environment():
   """
     Returns a Jinja2 template environment without autoescaping. Don't use this to
     generate HTML files!
   """
   from sitescripts.templateFilters import filters
   import jinja2
   env = jinja2.Environment(loader=jinja2.FileSystemLoader(siteScriptsPath))
   env.filters.update(filters)
   return env