| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| """This module defines a LRU cache class.""" |
| from __future__ import absolute_import |
|
|
| import datetime |
| import collections |
| from typing import TypeVar, Generic, Callable, Optional |
|
|
| KeyType = TypeVar("KeyType") |
| ValType = TypeVar("ValType") |
|
|
|
|
| class LRUCache(Generic[KeyType, ValType]): |
| """Class that implements LRU cache with expiring items. |
| |
| LRU caches remove items in a FIFO manner, such that the oldest |
| items to be used are the first to be removed. |
| If you attempt to retrieve a cache item that is older than the |
| expiration time, the item will be invalidated. |
| """ |
|
|
| class Element: |
| """Class describes the values in the cache. |
| |
| This object stores the value itself as well as a timestamp so that this |
| element can be invalidated if it becomes too old. |
| """ |
|
|
| def __init__(self, value: ValType, creation_time: datetime.datetime): |
| """Initialize an ``Element`` instance for ``LRUCache``. |
| |
| Args: |
| value (ValType): Value that is stored in cache. |
| creation_time (datetime.datetime): Time at which cache item was created. |
| """ |
| self.value = value |
| self.creation_time = creation_time |
|
|
| def __init__( |
| self, |
| max_cache_items: int, |
| expiration_horizon: datetime.timedelta, |
| retrieval_function: Callable[[KeyType, ValType], ValType], |
| ) -> None: |
| """Initialize an ``LRUCache`` instance. |
| |
| Args: |
| max_cache_items (int): Maximum number of items to store in cache. |
| expiration_horizon (datetime.timedelta): Maximum time duration a cache element can |
| persist before being invalidated. |
| retrieval_function (Callable[[KeyType, ValType], ValType]): Function which maps cache |
| keys and current values to new values. This function must have kwarg arguments |
| ``key`` and ``value``. This function is called as a fallback when the key |
| is not found in the cache, or a key has expired. |
| |
| """ |
| self._max_cache_items = max_cache_items |
| self._lru_cache: collections.OrderedDict = collections.OrderedDict() |
| self._expiration_horizon = expiration_horizon |
| self._retrieval_function = retrieval_function |
|
|
| def __len__(self) -> int: |
| """Returns number of elements in cache.""" |
| return len(self._lru_cache) |
|
|
| def __contains__(self, key: KeyType) -> bool: |
| """Returns True if key is found in cache, False otherwise. |
| |
| Args: |
| key (KeyType): Key in cache to retrieve. |
| """ |
| return key in self._lru_cache |
|
|
| def clear(self) -> None: |
| """Deletes all elements from the cache.""" |
| self._lru_cache.clear() |
|
|
| def get(self, key: KeyType, data_source_fallback: Optional[bool] = True) -> ValType: |
| """Returns value corresponding to key in cache. |
| |
| Args: |
| key (KeyType): Key in cache to retrieve. |
| data_source_fallback (Optional[bool]): True if data should be retrieved if |
| it's stale or not in cache. Default: True. |
| Raises: |
| KeyError: If key is not found in cache or is outdated and |
| ``data_source_fallback`` is False. |
| """ |
| if data_source_fallback: |
| if key in self._lru_cache: |
| return self._get_item(key, False) |
| self.put(key) |
| return self._get_item(key, False) |
| return self._get_item(key, True) |
|
|
| def put(self, key: KeyType, value: Optional[ValType] = None) -> None: |
| """Adds key to cache using ``retrieval_function``. |
| |
| If value is provided, this is used instead. If the key is already in cache, |
| the old element is removed. If the cache size exceeds the size limit, old |
| elements are removed in order to meet the limit. |
| |
| Args: |
| key (KeyType): Key in cache to retrieve. |
| value (Optional[ValType]): Value to store for key. Default: None. |
| """ |
| curr_value = None |
| if key in self._lru_cache: |
| curr_value = self._lru_cache.pop(key) |
|
|
| while len(self._lru_cache) >= self._max_cache_items: |
| self._lru_cache.popitem(last=False) |
|
|
| if value is None: |
| value = self._retrieval_function( |
| key=key, value=curr_value.element if curr_value else None |
| ) |
|
|
| self._lru_cache[key] = self.Element( |
| value=value, creation_time=datetime.datetime.now(tz=datetime.timezone.utc) |
| ) |
|
|
| def _get_item(self, key: KeyType, fail_on_old_value: bool) -> ValType: |
| """Returns value from cache corresponding to key. |
| |
| If ``fail_on_old_value``, a KeyError is raised instead of a new value |
| getting fetched. |
| |
| Args: |
| key (KeyType): Key in cache to retrieve. |
| fail_on_old_value (bool): True if a KeyError is raised when the cache value |
| is old. |
| |
| Raises: |
| KeyError: If key is not in cache or if key is old in cache |
| and fail_on_old_value is True. |
| """ |
| try: |
| element = self._lru_cache.pop(key) |
| curr_time = datetime.datetime.now(tz=datetime.timezone.utc) |
| element_age = curr_time - element.creation_time |
| if element_age > self._expiration_horizon: |
| if fail_on_old_value: |
| raise KeyError( |
| f"{key} has aged beyond allowed time {self._expiration_horizon}. " |
| f"Element created at {element.creation_time}." |
| ) |
| element.value = self._retrieval_function( |
| key=key, value=element.value |
| ) |
| element.creation_time = curr_time |
| self._lru_cache[key] = element |
| return element.value |
| except KeyError: |
| raise KeyError(f"{key} not found in LRUCache!") |
|
|
