| """ |
| This caching is very important for speed and memory optimizations. There's |
| nothing really spectacular, just some decorators. The following cache types are |
| available: |
| |
| - ``time_cache`` can be used to cache something for just a limited time span, |
| which can be useful if there's user interaction and the user cannot react |
| faster than a certain time. |
| |
| This module is one of the reasons why |jedi| is not thread-safe. As you can see |
| there are global variables, which are holding the cache information. Some of |
| these variables are being cleaned after every API usage. |
| """ |
| import time |
| from functools import wraps |
| from typing import Any, Dict, Tuple |
|
|
| from jedi import settings |
| from parso.cache import parser_cache |
|
|
| _time_caches: Dict[str, Dict[Any, Tuple[float, Any]]] = {} |
|
|
|
|
| def clear_time_caches(delete_all: bool = False) -> None: |
| """ Jedi caches many things, that should be completed after each completion |
| finishes. |
| |
| :param delete_all: Deletes also the cache that is normally not deleted, |
| like parser cache, which is important for faster parsing. |
| """ |
| global _time_caches |
|
|
| if delete_all: |
| for cache in _time_caches.values(): |
| cache.clear() |
| parser_cache.clear() |
| else: |
| |
| for tc in _time_caches.values(): |
| |
| for key, (t, value) in list(tc.items()): |
| if t < time.time(): |
| |
| del tc[key] |
|
|
|
|
| def signature_time_cache(time_add_setting): |
| """ |
| This decorator works as follows: Call it with a setting and after that |
| use the function with a callable that returns the key. |
| But: This function is only called if the key is not available. After a |
| certain amount of time (`time_add_setting`) the cache is invalid. |
| |
| If the given key is None, the function will not be cached. |
| """ |
| def _temp(key_func): |
| dct = {} |
| _time_caches[time_add_setting] = dct |
|
|
| def wrapper(*args, **kwargs): |
| generator = key_func(*args, **kwargs) |
| key = next(generator) |
| try: |
| expiry, value = dct[key] |
| if expiry > time.time(): |
| return value |
| except KeyError: |
| pass |
|
|
| value = next(generator) |
| time_add = getattr(settings, time_add_setting) |
| if key is not None: |
| dct[key] = time.time() + time_add, value |
| return value |
| return wrapper |
| return _temp |
|
|
|
|
| def time_cache(seconds): |
| def decorator(func): |
| cache = {} |
|
|
| @wraps(func) |
| def wrapper(*args, **kwargs): |
| key = (args, frozenset(kwargs.items())) |
| try: |
| created, result = cache[key] |
| if time.time() < created + seconds: |
| return result |
| except KeyError: |
| pass |
| result = func(*args, **kwargs) |
| cache[key] = time.time(), result |
| return result |
|
|
| wrapper.clear_cache = lambda: cache.clear() |
| return wrapper |
|
|
| return decorator |
|
|
|
|
| def memoize_method(method): |
| """A normal memoize function.""" |
| @wraps(method) |
| def wrapper(self, *args, **kwargs): |
| cache_dict = self.__dict__.setdefault('_memoize_method_dct', {}) |
| dct = cache_dict.setdefault(method, {}) |
| key = (args, frozenset(kwargs.items())) |
| try: |
| return dct[key] |
| except KeyError: |
| result = method(self, *args, **kwargs) |
| dct[key] = result |
| return result |
| return wrapper |
|
|
