Async versions of decorators?

[pjz]

For fluency I really like the decorator-style caching, but they don't work when used to decorate async functions - which, I think, are functions you'd frequently want to cache because they're often used when doing I/O.

[pjz]

Here's an async-compatible version of the cachetools.cached decorator, for instance:

def cached(cache, key=cachetools.keys.hashkey, lock=None):                                                             
    """                                                                                                                
    Decorator to wrap an async function with a memoizing callable that saves results in a cache.                       
    """                                                                                                                
    def decorator(func):                                                                                               
        if cache is None:                                                                                              
            async def wrapper(*args, **kwargs):                                                                        
                return await func(*args, **kwargs)                                                                           
        elif lock is None:                                                                                             
            async def wrapper(*args, **kwargs):                                                                        
                k = key(*args, **kwargs)                                                                               
                try:                                                                                                   
                    return cache[k]                                                                                    
                except KeyError:                                                                                       
                    pass  # key not found                                                                              
                v = await func(*args, **kwargs)                                                                        
                try:                                                                                                   
                    cache[k] = v                                                                                       
                except ValueError:                                                                                     
                    pass  # value too large                                                                            
                return v                                                                                               
        else:                                                                                                          
            async def wrapper(*args, **kwargs):                                                                        
                k = key(*args, **kwargs)                                                                               
                try:                                                                                                   
                    with lock:                                                                                         
                        return cache[k]                                                                                
                except KeyError:                                                                                       
                    pass  # key not found                                                                              
                v = await func(*args, **kwargs)                                                                        
                try:                                                                                                   
                    with lock:                                                                                         
                        cache[k] = v                                                                                   
                except ValueError:                                                                                     
                    pass  # value too large                                                                            
                return v                                                                                               
        return update_wrapper(wrapper, func)                                                                           
    return decorator    

[tkem]

Please have a look at #92, #112 and https://github.com/hephex/asyncache.