Add support for decorating async functions with pn.io.cache

panel/io/cache.py

@@ -20,6 +20,8 @@
 
 import param
 
+from param.parameterized import iscoroutinefunction
+
 from .state import state
 
 #---------------------------------------------------------------------
@@ -351,8 +353,7 @@ def cache(
 
  lock = threading.RLock()
 
- @functools.wraps(func)
- def wrapped_func(*args, **kwargs):
+ def hash_func(*args, **kwargs):
  global func_hash
  # Handle param.depends method by adding parameters to arguments
  func_name = func.__name__
@@ -396,18 +397,39 @@ def wrapped_func(*args, **kwargs):
  _cleanup_ttl(func_cache, ttl, time)
 
  if hash_value in func_cache:
- with lock:
- ret, ts, count, _ = func_cache[hash_value]
- func_cache[hash_value] = (ret, ts, count+1, time)
- return ret
+ return func_cache, hash_value, time
 
  if max_items is not None:
  _cleanup_cache(func_cache, policy, max_items, time)
 
- ret = func(*args, **kwargs)
- with lock:
- func_cache[hash_value] = (ret, time, 0, time)
- return ret
+ return func_cache, hash_value, time
+
+ if iscoroutinefunction(func):
+ @functools.wraps(func)
+ async def wrapped_func(*args, **kwargs):
+ func_cache, hash_value, time = hash_func(*args, **kwargs)
+ if hash_value in func_cache:
+ with lock:
+ ret, ts, count, _ = func_cache[hash_value]
+ func_cache[hash_value] = (ret, ts, count+1, time)
+ else:
+ ret = await func(*args, **kwargs)
+ with lock:
+ func_cache[hash_value] = (ret, time, 0, time)
+ return ret
+ else:
+ @functools.wraps(func)
+ def wrapped_func(*args, **kwargs):
+ func_cache, hash_value, time = hash_func(*args, **kwargs)
+ if hash_value in func_cache:
+ with lock:
+ ret, ts, count, _ = func_cache[hash_value]
+ func_cache[hash_value] = (ret, ts, count+1, time)
+ else:
+ ret = func(*args, **kwargs)
+ with lock:
+ func_cache[hash_value] = (ret, time, 0, time)
+ return ret
 
  def clear(session_context=None):
  global func_hash

panel/tests/io/test_cache.py

@@ -164,13 +164,27 @@ def function_with_args(a, b):
  OFFSET[(a, b)] = offset + 1
  return result
 
+async def async_function_with_args(a, b):
+ global OFFSET
+ offset = OFFSET.get((a, b), 0)
+ result = a + b + offset
+ OFFSET[(a, b)] = offset + 1
+ return result
+
 def test_cache_with_args():
  global OFFSET
  OFFSET.clear()
  fn = cache(function_with_args)
  assert fn(0, 0) == 0
  assert fn(0, 0) == 0
 
+async def test_async_cache_with_args():
+ global OFFSET
+ OFFSET.clear()
+ fn = cache(async_function_with_args)
+ assert (await fn(0, 0)) == 0
+ assert (await fn(0, 0)) == 0
+
 def test_cache_with_kwargs():
  global OFFSET
  OFFSET.clear()