È possibile chiamare shelve.open Python in modo annidato?

Question

Sto provando a scrivere una libreria di memoization che utilizza shelve per memorizzare i valori di ritorno in modo persistente. Se ho memorizzato funzioni che chiamano altre funzioni memorizzate, mi chiedo come aprire correttamente il file shelf.

import shelve 
import functools 


def cache(filename): 
    def decorating_function(user_function): 
     def wrapper(*args, **kwds): 
      key = str(hash(functools._make_key(args, kwds, typed=False))) 
      with shelve.open(filename, writeback=True) as cache: 
       if key in cache: 
        return cache[key] 
       else: 
        result = user_function(*args, **kwds) 
        cache[key] = result 
        return result 

     return functools.update_wrapper(wrapper, user_function) 

    return decorating_function 


@cache(filename='cache') 
def expensive_calculation(): 
    print('inside function') 
    return 


@cache(filename='cache') 
def other_expensive_calculation(): 
    print('outside function') 
    return expensive_calculation() 

other_expensive_calculation() 

Solo che questa non funziona

$ python3 shelve_test.py 
outside function 
Traceback (most recent call last): 
    File "shelve_test.py", line 33, in <module> 
    other_expensive_calculation() 
    File "shelve_test.py", line 13, in wrapper 
    result = user_function(*args, **kwds) 
    File "shelve_test.py", line 31, in other_expensive_calculation 
    return expensive_calculation() 
    File "shelve_test.py", line 9, in wrapper 
    with shelve.open(filename, writeback=True) as cache: 
    File "/usr/local/Cellar/python3/3.4.1/Frameworks/Python.framework/Versions/3.4/lib/python3.4/shelve.py", line 239, in open 
    return DbfilenameShelf(filename, flag, protocol, writeback) 
    File "/usr/local/Cellar/python3/3.4.1/Frameworks/Python.framework/Versions/3.4/lib/python3.4/shelve.py", line 223, in __init__ 
    Shelf.__init__(self, dbm.open(filename, flag), protocol, writeback) 
    File "/usr/local/Cellar/python3/3.4.1/Frameworks/Python.framework/Versions/3.4/lib/python3.4/dbm/__init__.py", line 94, in open 
    return mod.open(file, flag, mode) 
_gdbm.error: [Errno 35] Resource temporarily unavailable 

Cosa consigliate per una soluzione a questo tipo di problema.

Answer 1

Piuttosto che cercare di nido chiamate ad aprire (che, come si è scoperto, non funziona), si potrebbe rendere il vostro decoratore mantenere un riferimento al manico restituito da shelve.open, e poi se esiste ed è ancora aperto, ri-uso che per chiamate successive:

import shelve 
import functools 

def _check_cache(cache_, key, func, args, kwargs): 
    if key in cache_: 
     print("Using cached results") 
     return cache_[key] 
    else: 
     print("No cached results, calling function") 
     result = func(*args, **kwargs) 
     cache_[key] = result 
     return result 

def cache(filename): 
    def decorating_function(user_function): 
     def wrapper(*args, **kwds): 
      args_key = str(hash(functools._make_key(args, kwds, typed=False))) 
      func_key = '.'.join([user_function.__module__, user_function.__name__]) 
      key = func_key + args_key 
      handle_name = "{}_handle".format(filename) 
      if (hasattr(cache, handle_name) and 
       not hasattr(getattr(cache, handle_name).dict, "closed") 
       ): 
       print("Using open handle") 
       return _check_cache(getattr(cache, handle_name), key, 
            user_function, args, kwds) 
      else: 
       print("Opening handle") 
       with shelve.open(filename, writeback=True) as c: 
        setattr(cache, handle_name, c) # Save a reference to the open handle 
        return _check_cache(c, key, user_function, args, kwds) 

     return functools.update_wrapper(wrapper, user_function) 
    return decorating_function 


@cache(filename='cache') 
def expensive_calculation(): 
    print('inside function') 
    return 


@cache(filename='cache') 
def other_expensive_calculation(): 
    print('outside function') 
    return expensive_calculation() 

other_expensive_calculation() 
print("Again") 
other_expensive_calculation() 

uscita:

Opening handle 
No cached results, calling function 
outside function 
Using open handle 
No cached results, calling function 
inside function 
Again 
Opening handle 
Using cached results 

Edit:

Si potrebbe anche implementare il decoratore con un WeakValueDictionary, che sembra un po 'più leggibile:

from weakref import WeakValueDictionary 

_handle_dict = WeakValueDictionary() 
def cache(filename): 
    def decorating_function(user_function): 
     def wrapper(*args, **kwds): 
      args_key = str(hash(functools._make_key(args, kwds, typed=False))) 
      func_key = '.'.join([user_function.__module__, user_function.__name__]) 
      key = func_key + args_key 
      handle_name = "{}_handle".format(filename) 
      if handle_name in _handle_dict: 
       print("Using open handle") 
       return _check_cache(_handle_dict[handle_name], key, 
            user_function, args, kwds) 
      else: 
       print("Opening handle") 
       with shelve.open(filename, writeback=True) as c: 
        _handle_dict[handle_name] = c 
        return _check_cache(c, key, user_function, args, kwds) 

     return functools.update_wrapper(wrapper, user_function) 
    return decorating_function 

Appena non ci sono altri riferimenti a una maniglia, verrà eliminato dal dizionario Dal momento che il nostro handle esce dall'ambito solo quando termina la chiamata più esterna a una funzione decorata, avremo sempre una voce nel dict mentre una maniglia è aperta e nessuna voce subito dopo la chiusura.

Answer 2

Si sta aprendo il file due volte ma in realtà non lo si chiude per aggiornare il file per qualsiasi utilizzo. Utilizzare f.close() alla fine.

Answer 3

No, è possibile che non siano nidificate le istanze shelve con lo stesso nome file.

Il modulo shelve non supporta l'accesso simultaneo in lettura/scrittura agli oggetti shelved. (Gli accessi multipli simultanei in lettura sono sicuri). Quando un programma ha uno scaffale aperto per la scrittura, nessun altro programma dovrebbe averlo aperto per la lettura o la scrittura. Il blocco dei file Unix può essere utilizzato per risolvere questo problema, ma questo differisce tra le versioni di Unix e richiede conoscenze sull'implementazione del database utilizzata.

https://docs.python.org/3/library/shelve.html#restrictions