¿Puedo memorizar un generador de Python?

Question

Tengo una función llamada runquery que hace llamadas a una base de datos y luego cede las filas, una por una. Escribí un decorador de memoise (o más exactamente, acabo de robar uno de this stackoverflow question), pero en las llamadas siguientes simplemente produce una secuencia vacía, presumiblemente porque los valores de un generador solo pueden obtenerse una vez.

¿Cómo podría modificar el decorador de memoria que funciona para los generadores Python? Me doy cuenta de que tendré que almacenarlo en la memoria en algún momento, pero me gustaría manejar esto dentro del decorador y no modificar la función original.

El código actual de la función memoization es:

def memoized(f): 
    # Warning: Doesn't work if f yields values 
    cache={} 
    def ret(*args): 
     if args in cache: 
      return cache[args] 
     else: 
      answer=f(*args) 
      cache[args]=answer 
      return answer 
    return ret 

Answer 1

me di cuenta que es algo así como una vieja pregunta, pero para aquellos que quieren una solución completa: aquí está uno, basado en la sugerencia de jsbueno:

from itertools import tee 
from types import GeneratorType 

Tee = tee([], 1)[0].__class__ 

def memoized(f): 
    cache={} 
    def ret(*args): 
     if args not in cache: 
      cache[args]=f(*args) 
     if isinstance(cache[args], (GeneratorType, Tee)): 
      # the original can't be used any more, 
      # so we need to change the cache as well 
      cache[args], r = tee(cache[args]) 
      return r 
     return cache[args] 
    return ret 

Answer 2

Sí. Hay un decorador publicado here. Tenga en cuenta que, como dice el afiche, usted pierde parte del beneficio de la evaluación perezosa.

def memoize(func): 
    def inner(arg): 
     if isinstance(arg, list): 
      # Make arg immutable 
      arg = tuple(arg) 
     if arg in inner.cache: 
      print "Using cache for %s" % repr(arg) 
      for i in inner.cache[arg]: 
       yield i 
     else: 
      print "Building new for %s" % repr(arg) 
      temp = [] 
      for i in func(arg): 
       temp.append(i) 
       yield i 
      inner.cache[arg] = temp 
    inner.cache = {} 
    return inner 


@memoize 
def gen(x): 
    if not x: 
     yield 0 
     return 

    for i in xrange(len(x)): 
     for a in gen(x[i + 1:]): 
      yield a + x[0] 


print "Round 1" 
for a in gen([2, 3, 4, 5]): 
    print a 

print 
print "Round 2" 
for a in gen([2, 3, 4, 5]): 
    print a 

Answer 3

from itertools import tee 

sequence, memoized_sequence = tee (sequence, 2) 

Listo.

¡Es más fácil para generadores porque la lib estándar tiene este método "tee"!