""" A context object for caching a function's return value each time it is called with the same input arguments. """ # Author: Gael Varoquaux # Copyright (c) 2009 Gael Varoquaux # License: BSD Style, 3 clauses. import asyncio import datetime import functools import inspect import logging import os import pathlib import pydoc import re import textwrap import time import tokenize import traceback import warnings import weakref from . import hashing from ._store_backends import CacheWarning # noqa from ._store_backends import FileSystemStoreBackend, StoreBackendBase from .func_inspect import (filter_args, format_call, format_signature, get_func_code, get_func_name) from .logger import Logger, format_time, pformat FIRST_LINE_TEXT = "# first line:" # TODO: The following object should have a data store object as a sub # object, and the interface to persist and query should be separated in # the data store. # # This would enable creating 'Memory' objects with a different logic for # pickling that would simply span a MemorizedFunc with the same # store (or do we want to copy it to avoid cross-talks?), for instance to # implement HDF5 pickling. # TODO: Same remark for the logger, and probably use the Python logging # mechanism. def extract_first_line(func_code): """ Extract the first line information from the function code text if available. """ if func_code.startswith(FIRST_LINE_TEXT): func_code = func_code.split('\n') first_line = int(func_code[0][len(FIRST_LINE_TEXT):]) func_code = '\n'.join(func_code[1:]) else: first_line = -1 return func_code, first_line class JobLibCollisionWarning(UserWarning): """ Warn that there might be a collision between names of functions. """ _STORE_BACKENDS = {'local': FileSystemStoreBackend} def register_store_backend(backend_name, backend): """Extend available store backends. The Memory, MemorizeResult and MemorizeFunc objects are designed to be agnostic to the type of store used behind. By default, the local file system is used but this function gives the possibility to extend joblib's memory pattern with other types of storage such as cloud storage (S3, GCS, OpenStack, HadoopFS, etc) or blob DBs. Parameters ---------- backend_name: str The name identifying the store backend being registered. For example, 'local' is used with FileSystemStoreBackend. backend: StoreBackendBase subclass The name of a class that implements the StoreBackendBase interface. """ if not isinstance(backend_name, str): raise ValueError("Store backend name should be a string, " "'{0}' given.".format(backend_name)) if backend is None or not issubclass(backend, StoreBackendBase): raise ValueError("Store backend should inherit " "StoreBackendBase, " "'{0}' given.".format(backend)) _STORE_BACKENDS[backend_name] = backend def _store_backend_factory(backend, location, verbose=0, backend_options=None): """Return the correct store object for the given location.""" if backend_options is None: backend_options = {} if isinstance(location, pathlib.Path): location = str(location) if isinstance(location, StoreBackendBase): return location elif isinstance(location, str): obj = None location = os.path.expanduser(location) # The location is not a local file system, we look in the # registered backends if there's one matching the given backend # name. for backend_key, backend_obj in _STORE_BACKENDS.items(): if backend == backend_key: obj = backend_obj() # By default, we assume the FileSystemStoreBackend can be used if no # matching backend could be found. if obj is None: raise TypeError('Unknown location {0} or backend {1}'.format( location, backend)) # The store backend is configured with the extra named parameters, # some of them are specific to the underlying store backend. obj.configure(location, verbose=verbose, backend_options=backend_options) return obj elif location is not None: warnings.warn( "Instantiating a backend using a {} as a location is not " "supported by joblib. Returning None instead.".format( location.__class__.__name__), UserWarning) return None def _build_func_identifier(func): """Build a roughly unique identifier for the cached function.""" modules, funcname = get_func_name(func) # We reuse historical fs-like way of building a function identifier return os.path.join(*modules, funcname) # An in-memory store to avoid looking at the disk-based function # source code to check if a function definition has changed _FUNCTION_HASHES = weakref.WeakKeyDictionary() ############################################################################### # class `MemorizedResult` ############################################################################### class MemorizedResult(Logger): """Object representing a cached value. Attributes ---------- location: str The location of joblib cache. Depends on the store backend used. func: function or str function whose output is cached. The string case is intended only for instantiation based on the output of repr() on another instance. (namely eval(repr(memorized_instance)) works). argument_hash: str hash of the function arguments. backend: str Type of store backend for reading/writing cache files. Default is 'local'. mmap_mode: {None, 'r+', 'r', 'w+', 'c'} The memmapping mode used when loading from cache numpy arrays. See numpy.load for the meaning of the different values. verbose: int verbosity level (0 means no message). timestamp, metadata: string for internal use only. """ def __init__(self, location, call_id, backend='local', mmap_mode=None, verbose=0, timestamp=None, metadata=None): Logger.__init__(self) self._call_id = call_id self.store_backend = _store_backend_factory(backend, location, verbose=verbose) self.mmap_mode = mmap_mode if metadata is not None: self.metadata = metadata else: self.metadata = self.store_backend.get_metadata(self._call_id) self.duration = self.metadata.get('duration', None) self.verbose = verbose self.timestamp = timestamp @property def func(self): return self.func_id @property def func_id(self): return self._call_id[0] @property def args_id(self): return self._call_id[1] @property def argument_hash(self): warnings.warn( "The 'argument_hash' attribute has been deprecated in version " "0.12 and will be removed in version 0.14.\n" "Use `args_id` attribute instead.", DeprecationWarning, stacklevel=2) return self.args_id def get(self): """Read value from cache and return it.""" try: return self.store_backend.load_item( self._call_id, timestamp=self.timestamp, metadata=self.metadata, verbose=self.verbose ) except ValueError as exc: new_exc = KeyError( "Error while trying to load a MemorizedResult's value. " "It seems that this folder is corrupted : {}".format( os.path.join(self.store_backend.location, *self._call_id))) raise new_exc from exc def clear(self): """Clear value from cache""" self.store_backend.clear_item(self._call_id) def __repr__(self): return '{}(location="{}", func="{}", args_id="{}")'.format( self.__class__.__name__, self.store_backend.location, *self._call_id ) def __getstate__(self): state = self.__dict__.copy() state['timestamp'] = None return state class NotMemorizedResult(object): """Class representing an arbitrary value. This class is a replacement for MemorizedResult when there is no cache. """ __slots__ = ('value', 'valid') def __init__(self, value): self.value = value self.valid = True def get(self): if self.valid: return self.value else: raise KeyError("No value stored.") def clear(self): self.valid = False self.value = None def __repr__(self): if self.valid: return ('{class_name}({value})' .format(class_name=self.__class__.__name__, value=pformat(self.value))) else: return self.__class__.__name__ + ' with no value' # __getstate__ and __setstate__ are required because of __slots__ def __getstate__(self): return {"valid": self.valid, "value": self.value} def __setstate__(self, state): self.valid = state["valid"] self.value = state["value"] ############################################################################### # class `NotMemorizedFunc` ############################################################################### class NotMemorizedFunc(object): """No-op object decorating a function. This class replaces MemorizedFunc when there is no cache. It provides an identical API but does not write anything on disk. Attributes ---------- func: callable Original undecorated function. """ # Should be a light as possible (for speed) def __init__(self, func): self.func = func def __call__(self, *args, **kwargs): return self.func(*args, **kwargs) def call_and_shelve(self, *args, **kwargs): return NotMemorizedResult(self.func(*args, **kwargs)) def __repr__(self): return '{0}(func={1})'.format(self.__class__.__name__, self.func) def clear(self, warn=True): # Argument "warn" is for compatibility with MemorizedFunc.clear pass def call(self, *args, **kwargs): return self.func(*args, **kwargs), {} def check_call_in_cache(self, *args, **kwargs): return False ############################################################################### # class `AsyncNotMemorizedFunc` ############################################################################### class AsyncNotMemorizedFunc(NotMemorizedFunc): async def call_and_shelve(self, *args, **kwargs): return NotMemorizedResult(await self.func(*args, **kwargs)) ############################################################################### # class `MemorizedFunc` ############################################################################### class MemorizedFunc(Logger): """Callable object decorating a function for caching its return value each time it is called. Methods are provided to inspect the cache or clean it. Attributes ---------- func: callable The original, undecorated, function. location: string The location of joblib cache. Depends on the store backend used. backend: str Type of store backend for reading/writing cache files. Default is 'local', in which case the location is the path to a disk storage. ignore: list or None List of variable names to ignore when choosing whether to recompute. mmap_mode: {None, 'r+', 'r', 'w+', 'c'} The memmapping mode used when loading from cache numpy arrays. See numpy.load for the meaning of the different values. compress: boolean, or integer Whether to zip the stored data on disk. If an integer is given, it should be between 1 and 9, and sets the amount of compression. Note that compressed arrays cannot be read by memmapping. verbose: int, optional The verbosity flag, controls messages that are issued as the function is evaluated. cache_validation_callback: callable, optional Callable to check if a result in cache is valid or is to be recomputed. When the function is called with arguments for which a cache exists, the callback is called with the cache entry's metadata as its sole argument. If it returns True, the cached result is returned, else the cache for these arguments is cleared and the result is recomputed. """ # ------------------------------------------------------------------------ # Public interface # ------------------------------------------------------------------------ def __init__(self, func, location, backend='local', ignore=None, mmap_mode=None, compress=False, verbose=1, timestamp=None, cache_validation_callback=None): Logger.__init__(self) self.mmap_mode = mmap_mode self.compress = compress self.func = func self.cache_validation_callback = cache_validation_callback self.func_id = _build_func_identifier(func) self.ignore = ignore if ignore is not None else [] self._verbose = verbose # retrieve store object from backend type and location. self.store_backend = _store_backend_factory(backend, location, verbose=verbose, backend_options=dict( compress=compress, mmap_mode=mmap_mode), ) if self.store_backend is not None: # Create func directory on demand. self.store_backend.store_cached_func_code([self.func_id]) self.timestamp = timestamp if timestamp is not None else time.time() try: functools.update_wrapper(self, func) except Exception: pass # Objects like ufunc don't like that if inspect.isfunction(func): doc = pydoc.TextDoc().document(func) # Remove blank line doc = doc.replace('\n', '\n\n', 1) # Strip backspace-overprints for compatibility with autodoc doc = re.sub('\x08.', '', doc) else: # Pydoc does a poor job on other objects doc = func.__doc__ self.__doc__ = 'Memoized version of %s' % doc self._func_code_info = None self._func_code_id = None def _is_in_cache_and_valid(self, call_id): """Check if the function call is cached and valid for given arguments. - Compare the function code with the one from the cached function, asserting if it has changed. - Check if the function call is present in the cache. - Call `cache_validation_callback` for user define cache validation. Returns True if the function call is in cache and can be used, and returns False otherwise. """ # Check if the code of the function has changed if not self._check_previous_func_code(stacklevel=4): return False # Check if this specific call is in the cache if not self.store_backend.contains_item(call_id): return False # Call the user defined cache validation callback metadata = self.store_backend.get_metadata(call_id) if (self.cache_validation_callback is not None and not self.cache_validation_callback(metadata)): self.store_backend.clear_item(call_id) return False return True def _cached_call(self, args, kwargs, shelving): """Call wrapped function and cache result, or read cache if available. This function returns the wrapped function output or a reference to the cached result. Arguments: ---------- args, kwargs: list and dict input arguments for wrapped function shelving: bool True when called via the call_and_shelve function. Returns ------- output: Output of the wrapped function if shelving is false, or a MemorizedResult reference to the value if shelving is true. metadata: dict containing the metadata associated with the call. """ args_id = self._get_args_id(*args, **kwargs) call_id = (self.func_id, args_id) _, func_name = get_func_name(self.func) func_info = self.store_backend.get_cached_func_info([self.func_id]) location = func_info['location'] if self._verbose >= 20: logging.basicConfig(level=logging.INFO) _, signature = format_signature(self.func, *args, **kwargs) self.info( textwrap.dedent( f""" Querying {func_name} with signature {signature}. (argument hash {args_id}) The store location is {location}. """ ) ) # Compare the function code with the previous to see if the # function code has changed and check if the results are present in # the cache. if self._is_in_cache_and_valid(call_id): if shelving: return self._get_memorized_result(call_id), {} try: start_time = time.time() output = self._load_item(call_id) if self._verbose > 4: self._print_duration(time.time() - start_time, context='cache loaded ') return output, {} except Exception: # XXX: Should use an exception logger _, signature = format_signature(self.func, *args, **kwargs) self.warn('Exception while loading results for ' '{}\n {}'.format(signature, traceback.format_exc())) if self._verbose > 10: self.warn( f"Computing func {func_name}, argument hash {args_id} " f"in location {location}" ) # Returns the output but not the metadata return self._call(call_id, args, kwargs, shelving) @property def func_code_info(self): # 3-tuple property containing: the function source code, source file, # and first line of the code inside the source file if hasattr(self.func, '__code__'): if self._func_code_id is None: self._func_code_id = id(self.func.__code__) elif id(self.func.__code__) != self._func_code_id: # Be robust to dynamic reassignments of self.func.__code__ self._func_code_info = None if self._func_code_info is None: # Cache the source code of self.func . Provided that get_func_code # (which should be called once on self) gets called in the process # in which self.func was defined, this caching mechanism prevents # undesired cache clearing when the cached function is called in # an environment where the introspection utilities get_func_code # relies on do not work (typically, in joblib child processes). # See #1035 for more info # TODO (pierreglaser): do the same with get_func_name? self._func_code_info = get_func_code(self.func) return self._func_code_info def call_and_shelve(self, *args, **kwargs): """Call wrapped function, cache result and return a reference. This method returns a reference to the cached result instead of the result itself. The reference object is small and pickeable, allowing to send or store it easily. Call .get() on reference object to get result. Returns ------- cached_result: MemorizedResult or NotMemorizedResult reference to the value returned by the wrapped function. The class "NotMemorizedResult" is used when there is no cache activated (e.g. location=None in Memory). """ # Return the wrapped output, without the metadata return self._cached_call(args, kwargs, shelving=True)[0] def __call__(self, *args, **kwargs): # Return the output, without the metadata return self._cached_call(args, kwargs, shelving=False)[0] def __getstate__(self): # Make sure self.func's source is introspected prior to being pickled - # code introspection utilities typically do not work inside child # processes _ = self.func_code_info # We don't store the timestamp when pickling, to avoid the hash # depending from it. state = self.__dict__.copy() state['timestamp'] = None # Invalidate the code id as id(obj) will be different in the child state['_func_code_id'] = None return state def check_call_in_cache(self, *args, **kwargs): """Check if function call is in the memory cache. Does not call the function or do any work besides func inspection and arg hashing. Returns ------- is_call_in_cache: bool Whether or not the result of the function has been cached for the input arguments that have been passed. """ call_id = (self.func_id, self._get_args_id(*args, **kwargs)) return self.store_backend.contains_item(call_id) # ------------------------------------------------------------------------ # Private interface # ------------------------------------------------------------------------ def _get_args_id(self, *args, **kwargs): """Return the input parameter hash of a result.""" return hashing.hash(filter_args(self.func, self.ignore, args, kwargs), coerce_mmap=self.mmap_mode is not None) def _hash_func(self): """Hash a function to key the online cache""" func_code_h = hash(getattr(self.func, '__code__', None)) return id(self.func), hash(self.func), func_code_h def _write_func_code(self, func_code, first_line): """ Write the function code and the filename to a file. """ # We store the first line because the filename and the function # name is not always enough to identify a function: people # sometimes have several functions named the same way in a # file. This is bad practice, but joblib should be robust to bad # practice. func_code = u'%s %i\n%s' % (FIRST_LINE_TEXT, first_line, func_code) self.store_backend.store_cached_func_code([self.func_id], func_code) # Also store in the in-memory store of function hashes is_named_callable = (hasattr(self.func, '__name__') and self.func.__name__ != '') if is_named_callable: # Don't do this for lambda functions or strange callable # objects, as it ends up being too fragile func_hash = self._hash_func() try: _FUNCTION_HASHES[self.func] = func_hash except TypeError: # Some callable are not hashable pass def _check_previous_func_code(self, stacklevel=2): """ stacklevel is the depth a which this function is called, to issue useful warnings to the user. """ # First check if our function is in the in-memory store. # Using the in-memory store not only makes things faster, but it # also renders us robust to variations of the files when the # in-memory version of the code does not vary try: if self.func in _FUNCTION_HASHES: # We use as an identifier the id of the function and its # hash. This is more likely to falsely change than have hash # collisions, thus we are on the safe side. func_hash = self._hash_func() if func_hash == _FUNCTION_HASHES[self.func]: return True except TypeError: # Some callables are not hashable pass # Here, we go through some effort to be robust to dynamically # changing code and collision. We cannot inspect.getsource # because it is not reliable when using IPython's magic "%run". func_code, source_file, first_line = self.func_code_info try: old_func_code, old_first_line = extract_first_line( self.store_backend.get_cached_func_code([self.func_id])) except (IOError, OSError): # some backend can also raise OSError self._write_func_code(func_code, first_line) return False if old_func_code == func_code: return True # We have differing code, is this because we are referring to # different functions, or because the function we are referring to has # changed? _, func_name = get_func_name(self.func, resolv_alias=False, win_characters=False) if old_first_line == first_line == -1 or func_name == '': if not first_line == -1: func_description = ("{0} ({1}:{2})" .format(func_name, source_file, first_line)) else: func_description = func_name warnings.warn(JobLibCollisionWarning( "Cannot detect name collisions for function '{0}'" .format(func_description)), stacklevel=stacklevel) # Fetch the code at the old location and compare it. If it is the # same than the code store, we have a collision: the code in the # file has not changed, but the name we have is pointing to a new # code block. if not old_first_line == first_line and source_file is not None: if os.path.exists(source_file): _, func_name = get_func_name(self.func, resolv_alias=False) num_lines = len(func_code.split('\n')) with tokenize.open(source_file) as f: on_disk_func_code = f.readlines()[ old_first_line - 1:old_first_line - 1 + num_lines - 1] on_disk_func_code = ''.join(on_disk_func_code) possible_collision = (on_disk_func_code.rstrip() == old_func_code.rstrip()) else: possible_collision = source_file.startswith(' 10: _, func_name = get_func_name(self.func, resolv_alias=False) self.warn("Function {0} (identified by {1}) has changed" ".".format(func_name, self.func_id)) self.clear(warn=True) return False def clear(self, warn=True): """Empty the function's cache.""" func_id = self.func_id if self._verbose > 0 and warn: self.warn("Clearing function cache identified by %s" % func_id) self.store_backend.clear_path([func_id, ]) func_code, _, first_line = self.func_code_info self._write_func_code(func_code, first_line) def call(self, *args, **kwargs): """Force the execution of the function with the given arguments. The output values will be persisted, i.e., the cache will be updated with any new values. Parameters ---------- *args: arguments The arguments. **kwargs: keyword arguments Keyword arguments. Returns ------- output : object The output of the function call. metadata : dict The metadata associated with the call. """ call_id = (self.func_id, self._get_args_id(*args, **kwargs)) # Return the output and the metadata return self._call(call_id, args, kwargs) def _call(self, call_id, args, kwargs, shelving=False): # Return the output and the metadata self._before_call(args, kwargs) start_time = time.time() output = self.func(*args, **kwargs) return self._after_call(call_id, args, kwargs, shelving, output, start_time) def _before_call(self, args, kwargs): if self._verbose > 0: print(format_call(self.func, args, kwargs)) def _after_call(self, call_id, args, kwargs, shelving, output, start_time): self.store_backend.dump_item(call_id, output, verbose=self._verbose) duration = time.time() - start_time if self._verbose > 0: self._print_duration(duration) metadata = self._persist_input(duration, call_id, args, kwargs) if shelving: return self._get_memorized_result(call_id, metadata), metadata if self.mmap_mode is not None: # Memmap the output at the first call to be consistent with # later calls output = self._load_item(call_id, metadata) return output, metadata def _persist_input(self, duration, call_id, args, kwargs, this_duration_limit=0.5): """ Save a small summary of the call using json format in the output directory. output_dir: string directory where to write metadata. duration: float time taken by hashing input arguments, calling the wrapped function and persisting its output. args, kwargs: list and dict input arguments for wrapped function this_duration_limit: float Max execution time for this function before issuing a warning. """ start_time = time.time() argument_dict = filter_args(self.func, self.ignore, args, kwargs) input_repr = dict((k, repr(v)) for k, v in argument_dict.items()) # This can fail due to race-conditions with multiple # concurrent joblibs removing the file or the directory metadata = { "duration": duration, "input_args": input_repr, "time": start_time, } self.store_backend.store_metadata(call_id, metadata) this_duration = time.time() - start_time if this_duration > this_duration_limit: # This persistence should be fast. It will not be if repr() takes # time and its output is large, because json.dump will have to # write a large file. This should not be an issue with numpy arrays # for which repr() always output a short representation, but can # be with complex dictionaries. Fixing the problem should be a # matter of replacing repr() above by something smarter. warnings.warn("Persisting input arguments took %.2fs to run." "If this happens often in your code, it can cause " "performance problems " "(results will be correct in all cases). " "The reason for this is probably some large input " "arguments for a wrapped function." % this_duration, stacklevel=5) return metadata def _get_memorized_result(self, call_id, metadata=None): return MemorizedResult(self.store_backend, call_id, metadata=metadata, timestamp=self.timestamp, verbose=self._verbose - 1) def _load_item(self, call_id, metadata=None): return self.store_backend.load_item(call_id, metadata=metadata, timestamp=self.timestamp, verbose=self._verbose) def _print_duration(self, duration, context=''): _, name = get_func_name(self.func) msg = f"{name} {context}- {format_time(duration)}" print(max(0, (80 - len(msg))) * '_' + msg) # ------------------------------------------------------------------------ # Private `object` interface # ------------------------------------------------------------------------ def __repr__(self): return '{class_name}(func={func}, location={location})'.format( class_name=self.__class__.__name__, func=self.func, location=self.store_backend.location,) ############################################################################### # class `AsyncMemorizedFunc` ############################################################################### class AsyncMemorizedFunc(MemorizedFunc): async def __call__(self, *args, **kwargs): out = self._cached_call(args, kwargs, shelving=False) out = await out if asyncio.iscoroutine(out) else out return out[0] # Don't return metadata async def call_and_shelve(self, *args, **kwargs): out = self._cached_call(args, kwargs, shelving=True) out = await out if asyncio.iscoroutine(out) else out return out[0] # Don't return metadata async def call(self, *args, **kwargs): out = super().call(*args, **kwargs) return await out if asyncio.iscoroutine(out) else out async def _call(self, call_id, args, kwargs, shelving=False): self._before_call(args, kwargs) start_time = time.time() output = await self.func(*args, **kwargs) return self._after_call( call_id, args, kwargs, shelving, output, start_time ) ############################################################################### # class `Memory` ############################################################################### class Memory(Logger): """ A context object for caching a function's return value each time it is called with the same input arguments. All values are cached on the filesystem, in a deep directory structure. Read more in the :ref:`User Guide `. Parameters ---------- location: str, pathlib.Path or None The path of the base directory to use as a data store or None. If None is given, no caching is done and the Memory object is completely transparent. This option replaces cachedir since version 0.12. backend: str, optional Type of store backend for reading/writing cache files. Default: 'local'. The 'local' backend is using regular filesystem operations to manipulate data (open, mv, etc) in the backend. mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional The memmapping mode used when loading from cache numpy arrays. See numpy.load for the meaning of the arguments. compress: boolean, or integer, optional Whether to zip the stored data on disk. If an integer is given, it should be between 1 and 9, and sets the amount of compression. Note that compressed arrays cannot be read by memmapping. verbose: int, optional Verbosity flag, controls the debug messages that are issued as functions are evaluated. bytes_limit: int | str, optional Limit in bytes of the size of the cache. By default, the size of the cache is unlimited. When reducing the size of the cache, ``joblib`` keeps the most recently accessed items first. If a str is passed, it is converted to a number of bytes using units { K | M | G} for kilo, mega, giga. **Note:** You need to call :meth:`joblib.Memory.reduce_size` to actually reduce the cache size to be less than ``bytes_limit``. **Note:** This argument has been deprecated. One should give the value of ``bytes_limit`` directly in :meth:`joblib.Memory.reduce_size`. backend_options: dict, optional Contains a dictionary of named parameters used to configure the store backend. """ # ------------------------------------------------------------------------ # Public interface # ------------------------------------------------------------------------ def __init__(self, location=None, backend='local', mmap_mode=None, compress=False, verbose=1, bytes_limit=None, backend_options=None): Logger.__init__(self) self._verbose = verbose self.mmap_mode = mmap_mode self.timestamp = time.time() if bytes_limit is not None: warnings.warn( "bytes_limit argument has been deprecated. It will be removed " "in version 1.5. Please pass its value directly to " "Memory.reduce_size.", category=DeprecationWarning ) self.bytes_limit = bytes_limit self.backend = backend self.compress = compress if backend_options is None: backend_options = {} self.backend_options = backend_options if compress and mmap_mode is not None: warnings.warn('Compressed results cannot be memmapped', stacklevel=2) self.location = location if isinstance(location, str): location = os.path.join(location, 'joblib') self.store_backend = _store_backend_factory( backend, location, verbose=self._verbose, backend_options=dict(compress=compress, mmap_mode=mmap_mode, **backend_options)) def cache(self, func=None, ignore=None, verbose=None, mmap_mode=False, cache_validation_callback=None): """ Decorates the given function func to only compute its return value for input arguments not cached on disk. Parameters ---------- func: callable, optional The function to be decorated ignore: list of strings A list of arguments name to ignore in the hashing verbose: integer, optional The verbosity mode of the function. By default that of the memory object is used. mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional The memmapping mode used when loading from cache numpy arrays. See numpy.load for the meaning of the arguments. By default that of the memory object is used. cache_validation_callback: callable, optional Callable to validate whether or not the cache is valid. When the cached function is called with arguments for which a cache exists, this callable is called with the metadata of the cached result as its sole argument. If it returns True, then the cached result is returned, else the cache for these arguments is cleared and recomputed. Returns ------- decorated_func: MemorizedFunc object The returned object is a MemorizedFunc object, that is callable (behaves like a function), but offers extra methods for cache lookup and management. See the documentation for :class:`joblib.memory.MemorizedFunc`. """ if (cache_validation_callback is not None and not callable(cache_validation_callback)): raise ValueError( "cache_validation_callback needs to be callable. " f"Got {cache_validation_callback}." ) if func is None: # Partial application, to be able to specify extra keyword # arguments in decorators return functools.partial( self.cache, ignore=ignore, mmap_mode=mmap_mode, verbose=verbose, cache_validation_callback=cache_validation_callback ) if self.store_backend is None: cls = (AsyncNotMemorizedFunc if asyncio.iscoroutinefunction(func) else NotMemorizedFunc) return cls(func) if verbose is None: verbose = self._verbose if mmap_mode is False: mmap_mode = self.mmap_mode if isinstance(func, MemorizedFunc): func = func.func cls = (AsyncMemorizedFunc if asyncio.iscoroutinefunction(func) else MemorizedFunc) return cls( func, location=self.store_backend, backend=self.backend, ignore=ignore, mmap_mode=mmap_mode, compress=self.compress, verbose=verbose, timestamp=self.timestamp, cache_validation_callback=cache_validation_callback ) def clear(self, warn=True): """ Erase the complete cache directory. """ if warn: self.warn('Flushing completely the cache') if self.store_backend is not None: self.store_backend.clear() # As the cache is completely clear, make sure the _FUNCTION_HASHES # cache is also reset. Else, for a function that is present in this # table, results cached after this clear will be have cache miss # as the function code is not re-written. _FUNCTION_HASHES.clear() def reduce_size(self, bytes_limit=None, items_limit=None, age_limit=None): """Remove cache elements to make the cache fit its limits. The limitation can impose that the cache size fits in ``bytes_limit``, that the number of cache items is no more than ``items_limit``, and that all files in cache are not older than ``age_limit``. Parameters ---------- bytes_limit: int | str, optional Limit in bytes of the size of the cache. By default, the size of the cache is unlimited. When reducing the size of the cache, ``joblib`` keeps the most recently accessed items first. If a str is passed, it is converted to a number of bytes using units { K | M | G} for kilo, mega, giga. items_limit: int, optional Number of items to limit the cache to. By default, the number of items in the cache is unlimited. When reducing the size of the cache, ``joblib`` keeps the most recently accessed items first. age_limit: datetime.timedelta, optional Maximum age of items to limit the cache to. When reducing the size of the cache, any items last accessed more than the given length of time ago are deleted. """ if bytes_limit is None: bytes_limit = self.bytes_limit if self.store_backend is None: # No cached results, this function does nothing. return if bytes_limit is None and items_limit is None and age_limit is None: # No limitation to impose, returning return # Defers the actual limits enforcing to the store backend. self.store_backend.enforce_store_limits( bytes_limit, items_limit, age_limit ) def eval(self, func, *args, **kwargs): """ Eval function func with arguments `*args` and `**kwargs`, in the context of the memory. This method works similarly to the builtin `apply`, except that the function is called only if the cache is not up to date. """ if self.store_backend is None: return func(*args, **kwargs) return self.cache(func)(*args, **kwargs) # ------------------------------------------------------------------------ # Private `object` interface # ------------------------------------------------------------------------ def __repr__(self): return '{class_name}(location={location})'.format( class_name=self.__class__.__name__, location=(None if self.store_backend is None else self.store_backend.location)) def __getstate__(self): """ We don't store the timestamp when pickling, to avoid the hash depending from it. """ state = self.__dict__.copy() state['timestamp'] = None return state ############################################################################### # cache_validation_callback helpers ############################################################################### def expires_after(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0): """Helper cache_validation_callback to force recompute after a duration. Parameters ---------- days, seconds, microseconds, milliseconds, minutes, hours, weeks: numbers argument passed to a timedelta. """ delta = datetime.timedelta( days=days, seconds=seconds, microseconds=microseconds, milliseconds=milliseconds, minutes=minutes, hours=hours, weeks=weeks ) def cache_validation_callback(metadata): computation_age = time.time() - metadata['time'] return computation_age < delta.total_seconds() return cache_validation_callback