Trajectree 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

trajectree/quimb/quimb/utils.py

@@ -1,892 +0,0 @@
-"""Misc utility functions."""
-
-import collections
-import functools
-import itertools
-from importlib.util import find_spec
-
-try:
-    import cytoolz
-
-    last = cytoolz.last
-    concat = cytoolz.concat
-    frequencies = cytoolz.frequencies
-    partition_all = cytoolz.partition_all
-    merge_with = cytoolz.merge_with
-    valmap = cytoolz.valmap
-    partitionby = cytoolz.partitionby
-    concatv = cytoolz.concatv
-    partition = cytoolz.partition
-    partition_all = cytoolz.partition_all
-    compose = cytoolz.compose
-    identity = cytoolz.identity
-    isiterable = cytoolz.isiterable
-    unique = cytoolz.unique
-    keymap = cytoolz.keymap
-except ImportError:
-    import toolz
-
-    last = toolz.last
-    concat = toolz.concat
-    frequencies = toolz.frequencies
-    partition_all = toolz.partition_all
-    merge_with = toolz.merge_with
-    valmap = toolz.valmap
-    partition = toolz.partition
-    partitionby = toolz.partitionby
-    concatv = toolz.concatv
-    partition_all = toolz.partition_all
-    compose = toolz.compose
-    identity = toolz.identity
-    isiterable = toolz.isiterable
-    unique = toolz.unique
-    keymap = toolz.keymap
-
-
-_CHECK_OPT_MSG = "Option `{}` should be one of {}, but got '{}'."
-
-
-def check_opt(name, value, valid):
-    """Check whether ``value`` takes one of ``valid`` options, and raise an
-    informative error if not.
-    """
-    if value not in valid:
-        raise ValueError(_CHECK_OPT_MSG.format(name, valid, value))
-
-
-def find_library(x):
-    """Check if library is installed.
-
-    Parameters
-    ----------
-    x : str
-        Name of library
-
-    Returns
-    -------
-    bool
-        If library is available.
-    """
-    return find_spec(x) is not None
-
-
-def raise_cant_find_library_function(x, extra_msg=None):
-    """Return function to flag up a missing necessary library.
-
-    This is simplify the task of flagging optional dependencies only at the
-    point at which they are needed, and not earlier.
-
-    Parameters
-    ----------
-    x : str
-        Name of library
-    extra_msg : str, optional
-        Make the function print this message as well, for additional
-        information.
-
-    Returns
-    -------
-    callable
-        A mock function that when called, raises an import error specifying
-        the required library.
-    """
-
-    def function_that_will_raise(*_, **__):
-        error_msg = f"The library {x} is not installed. "
-        if extra_msg is not None:
-            error_msg += extra_msg
-        raise ImportError(error_msg)
-
-    return function_that_will_raise
-
-
-FOUND_TQDM = find_library("tqdm")
-if FOUND_TQDM:
-    from tqdm import tqdm
-
-    class continuous_progbar(tqdm):
-        """A continuous version of tqdm, so that it can be updated with a float
-        within some pre-given range, rather than a number of steps.
-
-        Parameters
-        ----------
-        args : (stop) or (start, stop)
-            Stopping point (and starting point if ``len(args) == 2``) of window
-            within which to evaluate progress.
-        total : int
-            The number of steps to represent the continuous progress with.
-        kwargs
-            Supplied to ``tqdm.tqdm``
-        """
-
-        def __init__(self, *args, total=100, **kwargs):
-            """ """
-            kwargs.setdefault("ascii", True)
-            super(continuous_progbar, self).__init__(
-                total=total, unit="%", **kwargs
-            )
-
-            if len(args) == 2:
-                self.start, self.stop = args
-            else:
-                self.start, self.stop = 0, args[0]
-
-            self.range = self.stop - self.start
-            self.step = 1
-
-        def cupdate(self, x):
-            """'Continuous' update of progress bar.
-
-            Parameters
-            ----------
-            x : float
-                Current position within the range ``[self.start, self.stop]``.
-            """
-            num_update = int(
-                (self.total + 1) * (x - self.start) / self.range - self.step
-            )
-            if num_update > 0:
-                self.update(num_update)
-                self.step += num_update
-
-    def progbar(*args, **kwargs):
-        kwargs.setdefault("ascii", True)
-        return tqdm(*args, **kwargs)
-
-else:  # pragma: no cover
-    extra_msg = "This is needed to show progress bars."
-    progbar = raise_cant_find_library_function("tqdm", extra_msg)
-    continuous_progbar = raise_cant_find_library_function("tqdm", extra_msg)
-
-
-def deprecated(fn, old_name, new_name):
-    """Mark a function as deprecated, and indicate the new name."""
-
-    @functools.wraps(fn)
-    def new_fn(*args, **kwargs):
-        import warnings
-
-        warnings.warn(
-            f"The {old_name} function is deprecated in favor of {new_name}",
-            Warning,
-        )
-        return fn(*args, **kwargs)
-
-    return new_fn
-
-
-def int2tup(x):
-    return (
-        x if isinstance(x, tuple) else (x,) if isinstance(x, int) else tuple(x)
-    )
-
-
-def ensure_dict(x):
-    """Make sure ``x`` is a ``dict``, creating an empty one if ``x is None``."""
-    if x is None:
-        return {}
-    return dict(x)
-
-
-def pairwise(iterable):
-    """Iterate over each pair of neighbours in ``iterable``."""
-    a, b = itertools.tee(iterable)
-    next(b, None)
-    return zip(a, b)
-
-
-def print_multi_line(*lines, max_width=None):
-    """Print multiple lines, with a maximum width."""
-    if max_width is None:
-        import shutil
-
-        max_width, _ = shutil.get_terminal_size()
-
-    max_line_lenth = max(len(ln) for ln in lines)
-
-    if max_line_lenth <= max_width:
-        for ln in lines:
-            print(ln)
-
-    else:  # pragma: no cover
-        max_width -= 10  # for ellipses and pad
-        n_lines = len(lines)
-        n_blocks = (max_line_lenth - 1) // max_width + 1
-
-        for i in range(n_blocks):
-            if i == 0:
-                for j, l in enumerate(lines):
-                    print(
-                        "..." if j == n_lines // 2 else "   ",
-                        l[i * max_width : (i + 1) * max_width],
-                        "..." if j == n_lines // 2 else "   ",
-                    )
-                print(("{:^" + str(max_width) + "}").format("..."))
-            elif i == n_blocks - 1:
-                for ln in lines:
-                    print("   ", ln[i * max_width : (i + 1) * max_width])
-            else:
-                for j, ln in enumerate(lines):
-                    print(
-                        "..." if j == n_lines // 2 else "   ",
-                        ln[i * max_width : (i + 1) * max_width],
-                        "..." if j == n_lines // 2 else "   ",
-                    )
-                print(("{:^" + str(max_width) + "}").format("..."))
-
-
-def format_number_with_error(x, err):
-    """Given ``x`` with error ``err``, format a string showing the relevant
-    digits of ``x`` with two significant digits of the error bracketed, and
-    overall exponent if necessary.
-
-    Parameters
-    ----------
-    x : float
-        The value to print.
-    err : float
-        The error on ``x``.
-
-    Returns
-    -------
-    str
-
-    Examples
-    --------
-
-        >>> print_number_with_uncertainty(0.1542412, 0.0626653)
-        '0.154(63)'
-
-        >>> print_number_with_uncertainty(-128124123097, 6424)
-        '-1.281241231(64)e+11'
-
-    """
-    # compute an overall scaling for both values
-    x_exponent = max(
-        int(f"{x:e}".split("e")[1]),
-        int(f"{err:e}".split("e")[1]) + 1,
-    )
-    # for readability try and show values close to 1 with no exponent
-    hide_exponent = (
-        # nicer showing 0.xxx(yy) than x.xx(yy)e-1
-        (x_exponent in (0, -1))
-        or
-        # also nicer showing xx.xx(yy) than x.xxx(yy)e+1
-        ((x_exponent == +1) and (err < abs(x / 10)))
-    )
-    if hide_exponent:
-        suffix = ""
-    else:
-        x = x / 10**x_exponent
-        err = err / 10**x_exponent
-        suffix = f"e{x_exponent:+03d}"
-
-    # work out how many digits to print
-    # format the main number and bracketed error
-    mantissa, exponent = f"{err:.1e}".split("e")
-    mantissa, exponent = mantissa.replace(".", ""), int(exponent)
-    return f"{x:.{abs(exponent) + 1}f}({mantissa}){suffix}"
-
-
-def save_to_disk(obj, fname, **dump_opts):
-    """Save an object to disk using joblib.dump."""
-    import joblib
-
-    return joblib.dump(obj, fname, **dump_opts)
-
-
-def load_from_disk(fname, **load_opts):
-    """Load an object form disk using joblib.load."""
-    import joblib
-
-    return joblib.load(fname, **load_opts)
-
-
-class Verbosify:  # pragma: no cover
-    """Decorator for making functions print their inputs. Simply for
-    illustrating a MPI example in the docs.
-    """
-
-    def __init__(self, fn, highlight=None, mpi=False):
-        self.fn = fn
-        self.highlight = highlight
-        self.mpi = mpi
-
-    def __call__(self, *args, **kwargs):
-        if self.mpi:
-            from mpi4py import MPI
-
-            pre_msg = f"{MPI.COMM_WORLD.Get_rank()}: "
-        else:
-            pre_msg = ""
-
-        if self.highlight is None:
-            print(f"{pre_msg} args {args}, kwargs {kwargs}")
-        else:
-            print(f"{pre_msg}{self.highlight}={kwargs[self.highlight]}")
-        return self.fn(*args, **kwargs)
-
-
-class oset:
-    """An ordered set which stores elements as the keys of dict (ordered as of
-    python 3.6). 'A few times' slower than using a set directly for small
-    sizes, but makes everything deterministic.
-    """
-
-    __slots__ = ("_d",)
-
-    def __init__(self, it=()):
-        self._d = dict.fromkeys(it)
-
-    @classmethod
-    def _from_dict(cls, d):
-        obj = object.__new__(oset)
-        obj._d = d
-        return obj
-
-    @classmethod
-    def from_dict(cls, d):
-        """Public method makes sure to copy incoming dictionary."""
-        return oset._from_dict(d.copy())
-
-    def copy(self):
-        return oset.from_dict(self._d)
-
-    def __deepcopy__(self, memo):
-        # always use hashable entries so just take normal copy
-        new = self.copy()
-        memo[id(self)] = new
-        return new
-
-    def add(self, k):
-        self._d[k] = None
-
-    def discard(self, k):
-        self._d.pop(k, None)
-
-    def remove(self, k):
-        del self._d[k]
-
-    def clear(self):
-        self._d.clear()
-
-    def update(self, *others):
-        for o in others:
-            try:
-                # oset
-                self._d.update(o._d)
-            except AttributeError:
-                # iterable
-                for k in o:
-                    self._d[k] = None
-
-    def union(self, *others):
-        u = self.copy()
-        u.update(*others)
-        return u
-
-    def intersection_update(self, *others):
-        if len(others) > 1:
-            si = set.intersection(*(set(o._d) for o in others))
-        else:
-            si = others[0]._d
-        self._d = {k: None for k in self._d if k in si}
-
-    def intersection(self, *others):
-        n_others = len(others)
-        if n_others == 0:
-            return self.copy()
-        elif n_others == 1:
-            si = others[0]._d
-        else:
-            si = set.intersection(*(set(o._d) for o in others))
-        return oset._from_dict({k: None for k in self._d if k in si})
-
-    def difference_update(self, *others):
-        if len(others) > 1:
-            su = set.union(*(set(o._d) for o in others))
-        else:
-            su = others[0]._d
-        self._d = {k: None for k in self._d if k not in su}
-
-    def difference(self, *others):
-        if len(others) > 1:
-            su = set.union(*(set(o._d) for o in others))
-        else:
-            su = others[0]._d
-        return oset._from_dict({k: None for k in self._d if k not in su})
-
-    def popleft(self):
-        k = next(iter(self._d))
-        del self._d[k]
-        return k
-
-    def popright(self):
-        return self._d.popitem()[0]
-
-    pop = popright
-
-    def __eq__(self, other):
-        if isinstance(other, oset):
-            return self._d == other._d
-        return False
-
-    def __or__(self, other):
-        return self.union(other)
-
-    def __ior__(self, other):
-        self.update(other)
-        return self
-
-    def __and__(self, other):
-        return self.intersection(other)
-
-    def __iand__(self, other):
-        self.intersection_update(other)
-        return self
-
-    def __sub__(self, other):
-        return self.difference(other)
-
-    def __isub__(self, other):
-        self.difference_update(other)
-        return self
-
-    def __len__(self):
-        return self._d.__len__()
-
-    def __iter__(self):
-        return self._d.__iter__()
-
-    def __contains__(self, x):
-        return self._d.__contains__(x)
-
-    def __repr__(self):
-        return f"oset({list(self._d)})"
-
-
-class LRU(collections.OrderedDict):
-    """Least recently used dict, which evicts old items. Taken from python
-    collections OrderedDict docs.
-    """
-
-    def __init__(self, maxsize, *args, **kwds):
-        self.maxsize = maxsize
-        super().__init__(*args, **kwds)
-
-    def __getitem__(self, key):
-        value = super().__getitem__(key)
-        self.move_to_end(key)
-        return value
-
-    def __setitem__(self, key, value):
-        if key in self:
-            self.move_to_end(key)
-        super().__setitem__(key, value)
-        if len(self) > self.maxsize:
-            oldest = next(iter(self))
-            del self[oldest]
-
-
-class ExponentialGeometricRollingDiffMean:
-    def __init__(self, factor=1 / 3, initial=1.0):
-        self.x_prev = None
-        self.dx = None
-        self.value = initial
-        self.factor = factor
-
-    def update(self, x):
-        if self.x_prev is not None:
-            # get the absolute change
-            self.dx = abs(x - self.x_prev)
-            # compute
-            self.value = self.value ** (1 - self.factor) * self.dx**self.factor
-        self.x_prev = x
-
-
-def gen_bipartitions(it):
-    """Generate all unique bipartitions of ``it``. Unique meaning
-    ``(1, 2), (3, 4)`` is considered the same as ``(3, 4), (1, 2)``.
-    """
-    n = len(it)
-    if n:
-        for i in range(1, 2 ** (n - 1)):
-            bitstring_repr = f"{i:0>{n}b}"
-            l, r = [], []
-            for b, x in zip(bitstring_repr, it):
-                (l if b == "0" else r).append(x)
-            yield l, r
-
-
-TREE_MAP_REGISTRY = {}
-TREE_APPLY_REGISTRY = {}
-TREE_ITER_REGISTRY = {}
-
-
-def tree_register_container(cls, mapper, iterator, applier):
-    """Register a new container type for use with ``tree_map`` and
-    ``tree_apply``.
-
-    Parameters
-    ----------
-    cls : type
-        The container type to register.
-    mapper : callable
-        A function that takes ``f``, ``tree`` and ``is_leaf`` and returns a new
-        tree of type ``cls`` with ``f`` applied to all leaves.
-    applier : callable
-        A function that takes ``f``, ``tree`` and ``is_leaf`` and applies ``f``
-        to all leaves in ``tree``.
-    """
-    TREE_MAP_REGISTRY[cls] = mapper
-    TREE_ITER_REGISTRY[cls] = iterator
-    TREE_APPLY_REGISTRY[cls] = applier
-
-
-IS_CONTAINER_CACHE = {}
-
-
-def is_not_container(x):
-    """The default function to determine if an object is a leaf. This simply
-    checks if the object is an instance of any of the registered container
-    types.
-    """
-    try:
-        return IS_CONTAINER_CACHE[x.__class__]
-    except KeyError:
-        isleaf = not any(isinstance(x, cls) for cls in TREE_MAP_REGISTRY)
-        IS_CONTAINER_CACHE[x.__class__] = isleaf
-        return isleaf
-
-
-def _tmap_identity(f, tree, is_leaf):
-    return tree
-
-
-TREE_MAPPER_CACHE = {}
-
-
-def tree_map(f, tree, is_leaf=is_not_container):
-    """Map ``f`` over all leaves in ``tree``, returning a new pytree.
-
-    Parameters
-    ----------
-    f : callable
-        A function to apply to all leaves in ``tree``.
-    tree : pytree
-        A nested sequence of tuples, lists, dicts and other objects.
-    is_leaf : callable
-        A function to determine if an object is a leaf, ``f`` is only applied
-        to objects for which ``is_leaf(x)`` returns ``True``.
-
-    Returns
-    -------
-    pytree
-    """
-    if is_leaf(tree):
-        return f(tree)
-
-    try:
-        return TREE_MAPPER_CACHE[tree.__class__](f, tree, is_leaf)
-    except KeyError:
-        # reverse so later registered classes take precedence
-        for cls, mapper in reversed(TREE_MAP_REGISTRY.items()):
-            if isinstance(tree, cls):
-                break
-        else:
-            # neither leaf nor container -> simply return it
-            mapper = _tmap_identity
-        TREE_MAPPER_CACHE[tree.__class__] = mapper
-        return mapper(f, tree, is_leaf)
-
-
-def empty(tree, is_leaf):
-    return iter(())
-
-
-TREE_ITER_CACHE = {}
-
-
-def tree_iter(tree, is_leaf=is_not_container):
-    """Iterate over all leaves in ``tree``.
-
-    Parameters
-    ----------
-    f : callable
-        A function to apply to all leaves in ``tree``.
-    tree : pytree
-        A nested sequence of tuples, lists, dicts and other objects.
-    is_leaf : callable
-        A function to determine if an object is a leaf, ``f`` is only applied
-        to objects for which ``is_leaf(x)`` returns ``True``.
-    """
-    if is_leaf(tree):
-        yield tree
-        return
-
-    try:
-        yield from TREE_ITER_CACHE[tree.__class__](tree, is_leaf)
-    except KeyError:
-        # reverse so later registered classes take precedence
-        for cls, iterator in reversed(TREE_ITER_REGISTRY.items()):
-            if isinstance(tree, cls):
-                break
-        else:
-            # neither leaf nor container -> simply ignore it
-            iterator = empty
-        TREE_ITER_CACHE[tree.__class__] = iterator
-        yield from iterator(tree, is_leaf)
-
-
-def nothing(f, tree, is_leaf):
-    pass
-
-
-TREE_APPLIER_CACHE = {}
-
-
-def tree_apply(f, tree, is_leaf=is_not_container):
-    """Apply ``f`` to all leaves in ``tree``, no new pytree is built.
-
-    Parameters
-    ----------
-    f : callable
-        A function to apply to all leaves in ``tree``.
-    tree : pytree
-        A nested sequence of tuples, lists, dicts and other objects.
-    is_leaf : callable
-        A function to determine if an object is a leaf, ``f`` is only applied
-        to objects for which ``is_leaf(x)`` returns ``True``.
-    """
-    if is_leaf(tree):
-        f(tree)
-        return
-
-    try:
-        TREE_APPLIER_CACHE[tree.__class__](f, tree, is_leaf)
-    except KeyError:
-        # reverse so later registered classes take precedence
-        for cls, applier in reversed(TREE_APPLY_REGISTRY.items()):
-            if isinstance(tree, cls):
-                break
-        else:
-            # neither leaf nor container -> simply ignore it
-            applier = nothing
-        TREE_APPLIER_CACHE[tree.__class__] = applier
-        applier(f, tree, is_leaf)
-
-
-class Leaf:
-    __slots__ = ()
-
-    def __repr__(self):
-        return "Leaf"
-
-
-Leaf = Leaf()
-
-
-def is_leaf_object(x):
-    return x is Leaf
-
-
-def tree_flatten(tree, get_ref=False, is_leaf=is_not_container):
-    """Flatten ``tree`` into a list of leaves.
-
-    Parameters
-    ----------
-    tree : pytree
-        A nested sequence of tuples, lists, dicts and other objects.
-    is_leaf : callable
-        A function to determine if an object is a leaf, only objects for which
-        ``is_leaf(x)`` returns ``True`` are returned in the flattened list.
-
-    Returns
-    -------
-    objs : list
-        The flattened list of leaf objects.
-    (ref_tree) : pytree
-        If ``get_ref`` is ``True``, a reference tree, with leaves of type
-        ``Leaf``, is returned which can be used to reconstruct the original
-        tree.
-    """
-    objs = []
-    if get_ref:
-        # return a new tree with Leaf leaves, as well as the flattened list
-
-        def f(x):
-            objs.append(x)
-            return Leaf
-
-        ref_tree = tree_map(f, tree, is_leaf)
-        return objs, ref_tree
-    else:
-        tree_apply(objs.append, tree, is_leaf)
-        return objs
-
-
-def tree_unflatten(objs, tree, is_leaf=is_leaf_object):
-    """Unflatten ``objs`` into a pytree of the same structure as ``tree``.
-
-    Parameters
-    ----------
-    objs : sequence
-        A sequence of objects to be unflattened into a pytree.
-    tree : pytree
-        A nested sequence of tuples, lists, dicts and other objects, the objs
-        will be inserted into a new pytree of the same structure.
-    is_leaf : callable
-        A function to determine if an object is a leaf, only objects for which
-        ``is_leaf(x)`` returns ``True`` will have the next item from ``objs``
-        inserted. By default checks for the ``Leaf`` object inserted by
-        ``tree_flatten(..., get_ref=True)``.
-
-    Returns
-    -------
-    pytree
-    """
-    objs = iter(objs)
-    return tree_map(lambda _: next(objs), tree, is_leaf)
-
-
-def tree_map_tuple(f, tree, is_leaf):
-    return tuple(tree_map(f, x, is_leaf) for x in tree)
-
-
-def tree_iter_tuple(tree, is_leaf):
-    for x in tree:
-        yield from tree_iter(x, is_leaf)
-
-
-def tree_apply_tuple(f, tree, is_leaf):
-    for x in tree:
-        tree_apply(f, x, is_leaf)
-
-
-tree_register_container(
-    tuple, tree_map_tuple, tree_iter_tuple, tree_apply_tuple
-)
-
-
-def tree_map_list(f, tree, is_leaf):
-    return [tree_map(f, x, is_leaf) for x in tree]
-
-
-def tree_iter_list(tree, is_leaf):
-    for x in tree:
-        yield from tree_iter(x, is_leaf)
-
-
-def tree_apply_list(f, tree, is_leaf):
-    for x in tree:
-        tree_apply(f, x, is_leaf)
-
-
-tree_register_container(list, tree_map_list, tree_iter_list, tree_apply_list)
-
-
-def tree_map_dict(f, tree, is_leaf):
-    return {k: tree_map(f, v, is_leaf) for k, v in tree.items()}
-
-
-def tree_iter_dict(tree, is_leaf):
-    for v in tree.values():
-        yield from tree_iter(v, is_leaf)
-
-
-def tree_apply_dict(f, tree, is_leaf):
-    for v in tree.values():
-        tree_apply(f, v, is_leaf)
-
-
-tree_register_container(dict, tree_map_dict, tree_iter_dict, tree_apply_dict)
-
-
-# a style to use for matplotlib that works with light and dark backgrounds
-NEUTRAL_STYLE = {
-    "axes.edgecolor": (0.5, 0.5, 0.5),
-    "axes.facecolor": (0, 0, 0, 0),
-    "axes.grid": True,
-    "axes.labelcolor": (0.5, 0.5, 0.5),
-    "axes.spines.right": False,
-    "axes.spines.top": False,
-    "figure.facecolor": (0, 0, 0, 0),
-    "grid.alpha": 0.1,
-    "grid.color": (0.5, 0.5, 0.5),
-    "legend.frameon": False,
-    "text.color": (0.5, 0.5, 0.5),
-    "xtick.color": (0.5, 0.5, 0.5),
-    "xtick.minor.visible": True,
-    "ytick.color": (0.5, 0.5, 0.5),
-    "ytick.minor.visible": True,
-}
-
-
-def default_to_neutral_style(fn):
-    """Wrap a function or method to use the neutral style by default."""
-
-    @functools.wraps(fn)
-    def wrapper(*args, style="neutral", show_and_close=True, **kwargs):
-        import matplotlib.pyplot as plt
-
-        if style == "neutral":
-            style = NEUTRAL_STYLE
-        elif not style:
-            style = {}
-
-        with plt.style.context(style):
-            out = fn(*args, **kwargs)
-
-            if show_and_close:
-                plt.show()
-                plt.close()
-
-            return out
-
-    return wrapper
-
-
-def autocorrect_kwargs(func=None, valid_kwargs=None):
-    """A decorator that suggests the right keyword arguments if you get them
-    wrong. Useful for functions with many specific options.
-
-    Parameters
-    ----------
-    func : callable, optional
-        The function to decorate.
-    valid_kwargs : sequence[str], optional
-        The valid keyword arguments for ``func``, if not given these are
-        inferred from the function signature.
-    """
-    if func is None:
-        # decorator with options
-        return functools.partial(autocorrect_kwargs, valid_kwargs=valid_kwargs)
-
-    if valid_kwargs is None:
-        import inspect
-
-        sig = inspect.signature(func)
-        params = sig.parameters
-        valid_kwargs = set(params.keys())
-    else:
-        valid_kwargs = set(valid_kwargs)
-
-    @functools.wraps(func)
-    def wrapped(*args, **kwargs):
-        wrong_opts = {kw for kw in kwargs if kw not in valid_kwargs}
-        if wrong_opts:
-            import difflib
-
-            right_opts = (
-                difflib.get_close_matches(opt, valid_kwargs, n=3)
-                for opt in wrong_opts
-            )
-            msg = "Option(s) {} not valid.\n Did you mean: {}?".format(
-                wrong_opts, ", ".join(map(str, right_opts))
-            )
-            print(msg)
-            raise ValueError(msg)
-
-        return func(*args, **kwargs)
-
-    return wrapped