s mode is not
    compatible with `timeout`.
    None is a marker for 'unset' that will be interpreted as n_jobs=1
    unless the call is performed under a :func:`~parallel_config`
    context manager that sets another value for ``n_jobs``.
    If n_jobs = 0 then a ValueError is raised.

verbose: int, default=0
    The verbosity level: if non zero, progress messages are
    printed. Above 50, the output is sent to stdout.
    The frequency of the messages increases with the verbosity level.
    If it more than 10, all iterations are reported.

temp_folder: str or None, default=None
    Folder to be used by the pool for memmapping large arrays
    for sharing memory with worker processes. If None, this will try in
    order:

    - a folder pointed by the ``JOBLIB_TEMP_FOLDER`` environment
      variable,
    - ``/dev/shm`` if the folder exists and is writable: this is a
      RAM disk filesystem available by default on modern Linux
      distributions,
    - the default system temporary folder that can be
      overridden with ``TMP``, ``TMPDIR`` or ``TEMP`` environment
      variables, typically ``/tmp`` under Unix operating systems.

max_nbytes: int, str, or None, optional, default='1M'
    Threshold on the size of arrays passed to the workers that
    triggers automated memory mapping in temp_folder. Can be an int
    in Bytes, or a human-readable string, e.g., '1M' for 1 megabyte.
    Use None to disable memmapping of large arrays.

mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, default='r'
    Memmapping mode for numpy arrays passed to workers. None will
    disable memmapping, other modes defined in the numpy.memmap doc:
    https://numpy.org/doc/stable/reference/generated/numpy.memmap.html
    Also, see 'max_nbytes' parameter documentation for more details.

prefer: str in {'processes', 'threads'} or None, default=None
    Soft hint to choose the default backend.
    The default process-based backend is 'loky' and the default
    thread-based backend is 'threading'. Ignored if the ``backend``
    parameter is specified.

require: 'sharedmem' or None, default=None
    Hard constraint to select the backend. If set to 'sharedmem',
    the selected backend will be single-host and thread-based.

inner_max_num_threads: int, default=None
    If not None, overwrites the limit set on the number of threads
    usable in some third-party library threadpools like OpenBLAS,
    MKL or OpenMP. This is only used with the ``loky`` backend.

backend_params: dict
    Additional parameters to pass to the backend constructor when
    backend is a string.

Notes
-----
Joblib tries to limit the oversubscription by limiting the number of
threads usable in some third-party library threadpools like OpenBLAS, MKL
or OpenMP. The default limit in each worker is set to
``max(cpu_count() // effective_n_jobs, 1)`` but this limit can be
overwritten with the ``inner_max_num_threads`` argument which will be used
to set this limit in the child processes.

.. versionadded:: 1.3

Examples
--------
>>> from operator import neg
>>> with parallel_config(backend='threading'):
...     print(Parallel()(delayed(neg)(i + 1) for i in range(5)))
...
[-1, -2, -3, -4, -5]

To use the 'ray' joblib backend add the following lines:

>>> from ray.util.joblib import register_ray  # doctest: +SKIP
>>> register_ray()  # doctest: +SKIP
>>> with parallel_config(backend="ray"):  # doctest: +SKIP
...     print(Parallel()(delayed(neg)(i + 1) for i in range(5)))
[-1, -2, -3, -4, -5]

r*