Add files using upload-large-folder tool

.gitattributes

@@ -362,3 +362,4 @@ llava_next/lib/python3.10/site-packages/scipy/optimize/_lsq/givens_elimination.c
 parrot/lib/python3.10/site-packages/torch/testing/_internal/generated/__pycache__/annotated_fn_args.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 llava_next/lib/python3.10/site-packages/scipy/optimize/_bglu_dense.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/torchvision.libs/libpng16.7f72a3c5.so.16 filter=lfs diff=lfs merge=lfs -text
+llava_next/lib/python3.10/site-packages/matplotlib/_qhull.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

llava_next/lib/python3.10/site-packages/matplotlib/__init__.pyi

@@ -0,0 +1,115 @@
+__all__ = [
+    "__bibtex__",
+    "__version__",
+    "__version_info__",
+    "set_loglevel",
+    "ExecutableNotFoundError",
+    "get_configdir",
+    "get_cachedir",
+    "get_data_path",
+    "matplotlib_fname",
+    "MatplotlibDeprecationWarning",
+    "RcParams",
+    "rc_params",
+    "rc_params_from_file",
+    "rcParamsDefault",
+    "rcParams",
+    "rcParamsOrig",
+    "defaultParams",
+    "rc",
+    "rcdefaults",
+    "rc_file_defaults",
+    "rc_file",
+    "rc_context",
+    "use",
+    "get_backend",
+    "interactive",
+    "is_interactive",
+    "colormaps",
+    "color_sequences",
+]
+
+import os
+from pathlib import Path
+
+from collections.abc import Callable, Generator
+import contextlib
+from packaging.version import Version
+
+from matplotlib._api import MatplotlibDeprecationWarning
+from typing import Any, NamedTuple
+
+class _VersionInfo(NamedTuple):
+    major: int
+    minor: int
+    micro: int
+    releaselevel: str
+    serial: int
+
+__bibtex__: str
+__version__: str
+__version_info__: _VersionInfo
+
+def set_loglevel(level: str) -> None: ...
+
+class _ExecInfo(NamedTuple):
+    executable: str
+    raw_version: str
+    version: Version
+
+class ExecutableNotFoundError(FileNotFoundError): ...
+
+def _get_executable_info(name: str) -> _ExecInfo: ...
+def get_configdir() -> str: ...
+def get_cachedir() -> str: ...
+def get_data_path() -> str: ...
+def matplotlib_fname() -> str: ...
+
+class RcParams(dict[str, Any]):
+    validate: dict[str, Callable]
+    def __init__(self, *args, **kwargs) -> None: ...
+    def _set(self, key: str, val: Any) -> None: ...
+    def _get(self, key: str) -> Any: ...
+    def __setitem__(self, key: str, val: Any) -> None: ...
+    def __getitem__(self, key: str) -> Any: ...
+    def __iter__(self) -> Generator[str, None, None]: ...
+    def __len__(self) -> int: ...
+    def find_all(self, pattern: str) -> RcParams: ...
+    def copy(self) -> RcParams: ...
+
+def rc_params(fail_on_error: bool = ...) -> RcParams: ...
+def rc_params_from_file(
+    fname: str | Path | os.PathLike,
+    fail_on_error: bool = ...,
+    use_default_template: bool = ...,
+) -> RcParams: ...
+
+rcParamsDefault: RcParams
+rcParams: RcParams
+rcParamsOrig: RcParams
+defaultParams: dict[str, Any]
+
+def rc(group: str, **kwargs) -> None: ...
+def rcdefaults() -> None: ...
+def rc_file_defaults() -> None: ...
+def rc_file(
+    fname: str | Path | os.PathLike, *, use_default_template: bool = ...
+) -> None: ...
+@contextlib.contextmanager
+def rc_context(
+    rc: dict[str, Any] | None = ..., fname: str | Path | os.PathLike | None = ...
+) -> Generator[None, None, None]: ...
+def use(backend: str, *, force: bool = ...) -> None: ...
+def get_backend() -> str: ...
+def interactive(b: bool) -> None: ...
+def is_interactive() -> bool: ...
+
+def _preprocess_data(
+    func: Callable | None = ...,
+    *,
+    replace_names: list[str] | None = ...,
+    label_namer: str | None = ...
+) -> Callable: ...
+
+from matplotlib.cm import _colormaps as colormaps
+from matplotlib.colors import _color_sequences as color_sequences

llava_next/lib/python3.10/site-packages/matplotlib/_api/__init__.py

@@ -0,0 +1,381 @@
+"""
+Helper functions for managing the Matplotlib API.
+
+This documentation is only relevant for Matplotlib developers, not for users.
+
+.. warning::
+
+    This module and its submodules are for internal use only.  Do not use them
+    in your own code.  We may change the API at any time with no warning.
+
+"""
+
+import functools
+import itertools
+import re
+import sys
+import warnings
+
+from .deprecation import (  # noqa: F401
+    deprecated, warn_deprecated,
+    rename_parameter, delete_parameter, make_keyword_only,
+    deprecate_method_override, deprecate_privatize_attribute,
+    suppress_matplotlib_deprecation_warning,
+    MatplotlibDeprecationWarning)
+
+
+class classproperty:
+    """
+    Like `property`, but also triggers on access via the class, and it is the
+    *class* that's passed as argument.
+
+    Examples
+    --------
+    ::
+
+        class C:
+            @classproperty
+            def foo(cls):
+                return cls.__name__
+
+        assert C.foo == "C"
+    """
+
+    def __init__(self, fget, fset=None, fdel=None, doc=None):
+        self._fget = fget
+        if fset is not None or fdel is not None:
+            raise ValueError('classproperty only implements fget.')
+        self.fset = fset
+        self.fdel = fdel
+        # docs are ignored for now
+        self._doc = doc
+
+    def __get__(self, instance, owner):
+        return self._fget(owner)
+
+    @property
+    def fget(self):
+        return self._fget
+
+
+# In the following check_foo() functions, the first parameter is positional-only to make
+# e.g. `_api.check_isinstance([...], types=foo)` work.
+
+def check_isinstance(types, /, **kwargs):
+    """
+    For each *key, value* pair in *kwargs*, check that *value* is an instance
+    of one of *types*; if not, raise an appropriate TypeError.
+
+    As a special case, a ``None`` entry in *types* is treated as NoneType.
+
+    Examples
+    --------
+    >>> _api.check_isinstance((SomeClass, None), arg=arg)
+    """
+    none_type = type(None)
+    types = ((types,) if isinstance(types, type) else
+             (none_type,) if types is None else
+             tuple(none_type if tp is None else tp for tp in types))
+
+    def type_name(tp):
+        return ("None" if tp is none_type
+                else tp.__qualname__ if tp.__module__ == "builtins"
+                else f"{tp.__module__}.{tp.__qualname__}")
+
+    for k, v in kwargs.items():
+        if not isinstance(v, types):
+            names = [*map(type_name, types)]
+            if "None" in names:  # Move it to the end for better wording.
+                names.remove("None")
+                names.append("None")
+            raise TypeError(
+                "{!r} must be an instance of {}, not a {}".format(
+                    k,
+                    ", ".join(names[:-1]) + " or " + names[-1]
+                    if len(names) > 1 else names[0],
+                    type_name(type(v))))
+
+
+def check_in_list(values, /, *, _print_supported_values=True, **kwargs):
+    """
+    For each *key, value* pair in *kwargs*, check that *value* is in *values*;
+    if not, raise an appropriate ValueError.
+
+    Parameters
+    ----------
+    values : iterable
+        Sequence of values to check on.
+    _print_supported_values : bool, default: True
+        Whether to print *values* when raising ValueError.
+    **kwargs : dict
+        *key, value* pairs as keyword arguments to find in *values*.
+
+    Raises
+    ------
+    ValueError
+        If any *value* in *kwargs* is not found in *values*.
+
+    Examples
+    --------
+    >>> _api.check_in_list(["foo", "bar"], arg=arg, other_arg=other_arg)
+    """
+    if not kwargs:
+        raise TypeError("No argument to check!")
+    for key, val in kwargs.items():
+        if val not in values:
+            msg = f"{val!r} is not a valid value for {key}"
+            if _print_supported_values:
+                msg += f"; supported values are {', '.join(map(repr, values))}"
+            raise ValueError(msg)
+
+
+def check_shape(shape, /, **kwargs):
+    """
+    For each *key, value* pair in *kwargs*, check that *value* has the shape *shape*;
+    if not, raise an appropriate ValueError.
+
+    *None* in the shape is treated as a "free" size that can have any length.
+    e.g. (None, 2) -> (N, 2)
+
+    The values checked must be numpy arrays.
+
+    Examples
+    --------
+    To check for (N, 2) shaped arrays
+
+    >>> _api.check_shape((None, 2), arg=arg, other_arg=other_arg)
+    """
+    for k, v in kwargs.items():
+        data_shape = v.shape
+
+        if (len(data_shape) != len(shape)
+                or any(s != t and t is not None for s, t in zip(data_shape, shape))):
+            dim_labels = iter(itertools.chain(
+                'NMLKJIH',
+                (f"D{i}" for i in itertools.count())))
+            text_shape = ", ".join([str(n) if n is not None else next(dim_labels)
+                                    for n in shape[::-1]][::-1])
+            if len(shape) == 1:
+                text_shape += ","
+
+            raise ValueError(
+                f"{k!r} must be {len(shape)}D with shape ({text_shape}), "
+                f"but your input has shape {v.shape}"
+            )
+
+
+def check_getitem(mapping, /, **kwargs):
+    """
+    *kwargs* must consist of a single *key, value* pair.  If *key* is in
+    *mapping*, return ``mapping[value]``; else, raise an appropriate
+    ValueError.
+
+    Examples
+    --------
+    >>> _api.check_getitem({"foo": "bar"}, arg=arg)
+    """
+    if len(kwargs) != 1:
+        raise ValueError("check_getitem takes a single keyword argument")
+    (k, v), = kwargs.items()
+    try:
+        return mapping[v]
+    except KeyError:
+        raise ValueError(
+            f"{v!r} is not a valid value for {k}; supported values are "
+            f"{', '.join(map(repr, mapping))}") from None
+
+
+def caching_module_getattr(cls):
+    """
+    Helper decorator for implementing module-level ``__getattr__`` as a class.
+
+    This decorator must be used at the module toplevel as follows::
+
+        @caching_module_getattr
+        class __getattr__:  # The class *must* be named ``__getattr__``.
+            @property  # Only properties are taken into account.
+            def name(self): ...
+
+    The ``__getattr__`` class will be replaced by a ``__getattr__``
+    function such that trying to access ``name`` on the module will
+    resolve the corresponding property (which may be decorated e.g. with
+    ``_api.deprecated`` for deprecating module globals).  The properties are
+    all implicitly cached.  Moreover, a suitable AttributeError is generated
+    and raised if no property with the given name exists.
+    """
+
+    assert cls.__name__ == "__getattr__"
+    # Don't accidentally export cls dunders.
+    props = {name: prop for name, prop in vars(cls).items()
+             if isinstance(prop, property)}
+    instance = cls()
+
+    @functools.cache
+    def __getattr__(name):
+        if name in props:
+            return props[name].__get__(instance)
+        raise AttributeError(
+            f"module {cls.__module__!r} has no attribute {name!r}")
+
+    return __getattr__
+
+
+def define_aliases(alias_d, cls=None):
+    """
+    Class decorator for defining property aliases.
+
+    Use as ::
+
+        @_api.define_aliases({"property": ["alias", ...], ...})
+        class C: ...
+
+    For each property, if the corresponding ``get_property`` is defined in the
+    class so far, an alias named ``get_alias`` will be defined; the same will
+    be done for setters.  If neither the getter nor the setter exists, an
+    exception will be raised.
+
+    The alias map is stored as the ``_alias_map`` attribute on the class and
+    can be used by `.normalize_kwargs` (which assumes that higher priority
+    aliases come last).
+    """
+    if cls is None:  # Return the actual class decorator.
+        return functools.partial(define_aliases, alias_d)
+
+    def make_alias(name):  # Enforce a closure over *name*.
+        @functools.wraps(getattr(cls, name))
+        def method(self, *args, **kwargs):
+            return getattr(self, name)(*args, **kwargs)
+        return method
+
+    for prop, aliases in alias_d.items():
+        exists = False
+        for prefix in ["get_", "set_"]:
+            if prefix + prop in vars(cls):
+                exists = True
+                for alias in aliases:
+                    method = make_alias(prefix + prop)
+                    method.__name__ = prefix + alias
+                    method.__doc__ = f"Alias for `{prefix + prop}`."
+                    setattr(cls, prefix + alias, method)
+        if not exists:
+            raise ValueError(
+                f"Neither getter nor setter exists for {prop!r}")
+
+    def get_aliased_and_aliases(d):
+        return {*d, *(alias for aliases in d.values() for alias in aliases)}
+
+    preexisting_aliases = getattr(cls, "_alias_map", {})
+    conflicting = (get_aliased_and_aliases(preexisting_aliases)
+                   & get_aliased_and_aliases(alias_d))
+    if conflicting:
+        # Need to decide on conflict resolution policy.
+        raise NotImplementedError(
+            f"Parent class already defines conflicting aliases: {conflicting}")
+    cls._alias_map = {**preexisting_aliases, **alias_d}
+    return cls
+
+
+def select_matching_signature(funcs, *args, **kwargs):
+    """
+    Select and call the function that accepts ``*args, **kwargs``.
+
+    *funcs* is a list of functions which should not raise any exception (other
+    than `TypeError` if the arguments passed do not match their signature).
+
+    `select_matching_signature` tries to call each of the functions in *funcs*
+    with ``*args, **kwargs`` (in the order in which they are given).  Calls
+    that fail with a `TypeError` are silently skipped.  As soon as a call
+    succeeds, `select_matching_signature` returns its return value.  If no
+    function accepts ``*args, **kwargs``, then the `TypeError` raised by the
+    last failing call is re-raised.
+
+    Callers should normally make sure that any ``*args, **kwargs`` can only
+    bind a single *func* (to avoid any ambiguity), although this is not checked
+    by `select_matching_signature`.
+
+    Notes
+    -----
+    `select_matching_signature` is intended to help implementing
+    signature-overloaded functions.  In general, such functions should be
+    avoided, except for back-compatibility concerns.  A typical use pattern is
+    ::
+
+        def my_func(*args, **kwargs):
+            params = select_matching_signature(
+                [lambda old1, old2: locals(), lambda new: locals()],
+                *args, **kwargs)
+            if "old1" in params:
+                warn_deprecated(...)
+                old1, old2 = params.values()  # note that locals() is ordered.
+            else:
+                new, = params.values()
+            # do things with params
+
+    which allows *my_func* to be called either with two parameters (*old1* and
+    *old2*) or a single one (*new*).  Note that the new signature is given
+    last, so that callers get a `TypeError` corresponding to the new signature
+    if the arguments they passed in do not match any signature.
+    """
+    # Rather than relying on locals() ordering, one could have just used func's
+    # signature (``bound = inspect.signature(func).bind(*args, **kwargs);
+    # bound.apply_defaults(); return bound``) but that is significantly slower.
+    for i, func in enumerate(funcs):
+        try:
+            return func(*args, **kwargs)
+        except TypeError:
+            if i == len(funcs) - 1:
+                raise
+
+
+def nargs_error(name, takes, given):
+    """Generate a TypeError to be raised by function calls with wrong arity."""
+    return TypeError(f"{name}() takes {takes} positional arguments but "
+                     f"{given} were given")
+
+
+def kwarg_error(name, kw):
+    """
+    Generate a TypeError to be raised by function calls with wrong kwarg.
+
+    Parameters
+    ----------
+    name : str
+        The name of the calling function.
+    kw : str or Iterable[str]
+        Either the invalid keyword argument name, or an iterable yielding
+        invalid keyword arguments (e.g., a ``kwargs`` dict).
+    """
+    if not isinstance(kw, str):
+        kw = next(iter(kw))
+    return TypeError(f"{name}() got an unexpected keyword argument '{kw}'")
+
+
+def recursive_subclasses(cls):
+    """Yield *cls* and direct and indirect subclasses of *cls*."""
+    yield cls
+    for subcls in cls.__subclasses__():
+        yield from recursive_subclasses(subcls)
+
+
+def warn_external(message, category=None):
+    """
+    `warnings.warn` wrapper that sets *stacklevel* to "outside Matplotlib".
+
+    The original emitter of the warning can be obtained by patching this
+    function back to `warnings.warn`, i.e. ``_api.warn_external =
+    warnings.warn`` (or ``functools.partial(warnings.warn, stacklevel=2)``,
+    etc.).
+    """
+    frame = sys._getframe()
+    for stacklevel in itertools.count(1):
+        if frame is None:
+            # when called in embedded context may hit frame is None
+            break
+        if not re.match(r"\A(matplotlib|mpl_toolkits)(\Z|\.(?!tests\.))",
+                        # Work around sphinx-gallery not setting __name__.
+                        frame.f_globals.get("__name__", "")):
+            break
+        frame = frame.f_back
+    # preemptively break reference cycle between locals and the frame
+    del frame
+    warnings.warn(message, category, stacklevel)

llava_next/lib/python3.10/site-packages/matplotlib/_api/__init__.pyi

@@ -0,0 +1,59 @@
+from collections.abc import Callable, Generator, Mapping, Sequence
+from typing import Any, Iterable, TypeVar, overload
+
+from numpy.typing import NDArray
+
+from .deprecation import (  # noqa: re-exported API
+    deprecated as deprecated,
+    warn_deprecated as warn_deprecated,
+    rename_parameter as rename_parameter,
+    delete_parameter as delete_parameter,
+    make_keyword_only as make_keyword_only,
+    deprecate_method_override as deprecate_method_override,
+    deprecate_privatize_attribute as deprecate_privatize_attribute,
+    suppress_matplotlib_deprecation_warning as suppress_matplotlib_deprecation_warning,
+    MatplotlibDeprecationWarning as MatplotlibDeprecationWarning,
+)
+
+_T = TypeVar("_T")
+
+class classproperty(Any):
+    def __init__(
+        self,
+        fget: Callable[[_T], Any],
+        fset: None = ...,
+        fdel: None = ...,
+        doc: str | None = None,
+    ): ...
+    # Replace return with Self when py3.9 is dropped
+    @overload
+    def __get__(self, instance: None, owner: None) -> classproperty: ...
+    @overload
+    def __get__(self, instance: object, owner: type[object]) -> Any: ...
+    @property
+    def fget(self) -> Callable[[_T], Any]: ...
+
+def check_isinstance(
+    types: type | tuple[type | None, ...], /, **kwargs: Any
+) -> None: ...
+def check_in_list(
+    values: Sequence[Any], /, *, _print_supported_values: bool = ..., **kwargs: Any
+) -> None: ...
+def check_shape(shape: tuple[int | None, ...], /, **kwargs: NDArray) -> None: ...
+def check_getitem(mapping: Mapping[Any, Any], /, **kwargs: Any) -> Any: ...
+def caching_module_getattr(cls: type) -> Callable[[str], Any]: ...
+@overload
+def define_aliases(
+    alias_d: dict[str, list[str]], cls: None = ...
+) -> Callable[[type[_T]], type[_T]]: ...
+@overload
+def define_aliases(alias_d: dict[str, list[str]], cls: type[_T]) -> type[_T]: ...
+def select_matching_signature(
+    funcs: list[Callable], *args: Any, **kwargs: Any
+) -> Any: ...
+def nargs_error(name: str, takes: int | str, given: int) -> TypeError: ...
+def kwarg_error(name: str, kw: str | Iterable[str]) -> TypeError: ...
+def recursive_subclasses(cls: type) -> Generator[type, None, None]: ...
+def warn_external(
+    message: str | Warning, category: type[Warning] | None = ...
+) -> None: ...

llava_next/lib/python3.10/site-packages/matplotlib/_api/deprecation.py

@@ -0,0 +1,513 @@
+"""
+Helper functions for deprecating parts of the Matplotlib API.
+
+This documentation is only relevant for Matplotlib developers, not for users.
+
+.. warning::
+
+    This module is for internal use only.  Do not use it in your own code.
+    We may change the API at any time with no warning.
+
+"""
+
+import contextlib
+import functools
+import inspect
+import math
+import warnings
+
+
+class MatplotlibDeprecationWarning(DeprecationWarning):
+    """A class for issuing deprecation warnings for Matplotlib users."""
+
+
+def _generate_deprecation_warning(
+        since, message='', name='', alternative='', pending=False, obj_type='',
+        addendum='', *, removal=''):
+    if pending:
+        if removal:
+            raise ValueError(
+                "A pending deprecation cannot have a scheduled removal")
+    else:
+        if not removal:
+            macro, meso, *_ = since.split('.')
+            removal = f'{macro}.{int(meso) + 2}'
+        removal = f"in {removal}"
+    if not message:
+        message = (
+            ("The %(name)s %(obj_type)s" if obj_type else "%(name)s")
+            + (" will be deprecated in a future version"
+               if pending else
+               " was deprecated in Matplotlib %(since)s and will be removed %(removal)s"
+               )
+            + "."
+            + (" Use %(alternative)s instead." if alternative else "")
+            + (" %(addendum)s" if addendum else ""))
+    warning_cls = (PendingDeprecationWarning if pending
+                   else MatplotlibDeprecationWarning)
+    return warning_cls(message % dict(
+        func=name, name=name, obj_type=obj_type, since=since, removal=removal,
+        alternative=alternative, addendum=addendum))
+
+
+def warn_deprecated(
+        since, *, message='', name='', alternative='', pending=False,
+        obj_type='', addendum='', removal=''):
+    """
+    Display a standardized deprecation.
+
+    Parameters
+    ----------
+    since : str
+        The release at which this API became deprecated.
+    message : str, optional
+        Override the default deprecation message.  The ``%(since)s``,
+        ``%(name)s``, ``%(alternative)s``, ``%(obj_type)s``, ``%(addendum)s``,
+        and ``%(removal)s`` format specifiers will be replaced by the values
+        of the respective arguments passed to this function.
+    name : str, optional
+        The name of the deprecated object.
+    alternative : str, optional
+        An alternative API that the user may use in place of the deprecated
+        API.  The deprecation warning will tell the user about this alternative
+        if provided.
+    pending : bool, optional
+        If True, uses a PendingDeprecationWarning instead of a
+        DeprecationWarning.  Cannot be used together with *removal*.
+    obj_type : str, optional
+        The object type being deprecated.
+    addendum : str, optional
+        Additional text appended directly to the final message.
+    removal : str, optional
+        The expected removal version.  With the default (an empty string), a
+        removal version is automatically computed from *since*.  Set to other
+        Falsy values to not schedule a removal date.  Cannot be used together
+        with *pending*.
+
+    Examples
+    --------
+    ::
+
+        # To warn of the deprecation of "matplotlib.name_of_module"
+        warn_deprecated('1.4.0', name='matplotlib.name_of_module',
+                        obj_type='module')
+    """
+    warning = _generate_deprecation_warning(
+        since, message, name, alternative, pending, obj_type, addendum,
+        removal=removal)
+    from . import warn_external
+    warn_external(warning, category=MatplotlibDeprecationWarning)
+
+
+def deprecated(since, *, message='', name='', alternative='', pending=False,
+               obj_type=None, addendum='', removal=''):
+    """
+    Decorator to mark a function, a class, or a property as deprecated.
+
+    When deprecating a classmethod, a staticmethod, or a property, the
+    ``@deprecated`` decorator should go *under* ``@classmethod`` and
+    ``@staticmethod`` (i.e., `deprecated` should directly decorate the
+    underlying callable), but *over* ``@property``.
+
+    When deprecating a class ``C`` intended to be used as a base class in a
+    multiple inheritance hierarchy, ``C`` *must* define an ``__init__`` method
+    (if ``C`` instead inherited its ``__init__`` from its own base class, then
+    ``@deprecated`` would mess up ``__init__`` inheritance when installing its
+    own (deprecation-emitting) ``C.__init__``).
+
+    Parameters are the same as for `warn_deprecated`, except that *obj_type*
+    defaults to 'class' if decorating a class, 'attribute' if decorating a
+    property, and 'function' otherwise.
+
+    Examples
+    --------
+    ::
+
+        @deprecated('1.4.0')
+        def the_function_to_deprecate():
+            pass
+    """
+
+    def deprecate(obj, message=message, name=name, alternative=alternative,
+                  pending=pending, obj_type=obj_type, addendum=addendum):
+        from matplotlib._api import classproperty
+
+        if isinstance(obj, type):
+            if obj_type is None:
+                obj_type = "class"
+            func = obj.__init__
+            name = name or obj.__name__
+            old_doc = obj.__doc__
+
+            def finalize(wrapper, new_doc):
+                try:
+                    obj.__doc__ = new_doc
+                except AttributeError:  # Can't set on some extension objects.
+                    pass
+                obj.__init__ = functools.wraps(obj.__init__)(wrapper)
+                return obj
+
+        elif isinstance(obj, (property, classproperty)):
+            if obj_type is None:
+                obj_type = "attribute"
+            func = None
+            name = name or obj.fget.__name__
+            old_doc = obj.__doc__
+
+            class _deprecated_property(type(obj)):
+                def __get__(self, instance, owner=None):
+                    if instance is not None or owner is not None \
+                            and isinstance(self, classproperty):
+                        emit_warning()
+                    return super().__get__(instance, owner)
+
+                def __set__(self, instance, value):
+                    if instance is not None:
+                        emit_warning()
+                    return super().__set__(instance, value)
+
+                def __delete__(self, instance):
+                    if instance is not None:
+                        emit_warning()
+                    return super().__delete__(instance)
+
+                def __set_name__(self, owner, set_name):
+                    nonlocal name
+                    if name == "<lambda>":
+                        name = set_name
+
+            def finalize(_, new_doc):
+                return _deprecated_property(
+                    fget=obj.fget, fset=obj.fset, fdel=obj.fdel, doc=new_doc)
+
+        else:
+            if obj_type is None:
+                obj_type = "function"
+            func = obj
+            name = name or obj.__name__
+            old_doc = func.__doc__
+
+            def finalize(wrapper, new_doc):
+                wrapper = functools.wraps(func)(wrapper)
+                wrapper.__doc__ = new_doc
+                return wrapper
+
+        def emit_warning():
+            warn_deprecated(
+                since, message=message, name=name, alternative=alternative,
+                pending=pending, obj_type=obj_type, addendum=addendum,
+                removal=removal)
+
+        def wrapper(*args, **kwargs):
+            emit_warning()
+            return func(*args, **kwargs)
+
+        old_doc = inspect.cleandoc(old_doc or '').strip('\n')
+
+        notes_header = '\nNotes\n-----'
+        second_arg = ' '.join([t.strip() for t in
+                               (message, f"Use {alternative} instead."
+                                if alternative else "", addendum) if t])
+        new_doc = (f"[*Deprecated*] {old_doc}\n"
+                   f"{notes_header if notes_header not in old_doc else ''}\n"
+                   f".. deprecated:: {since}\n"
+                   f"   {second_arg}")
+
+        if not old_doc:
+            # This is to prevent a spurious 'unexpected unindent' warning from
+            # docutils when the original docstring was blank.
+            new_doc += r'\ '
+
+        return finalize(wrapper, new_doc)
+
+    return deprecate
+
+
+class deprecate_privatize_attribute:
+    """
+    Helper to deprecate public access to an attribute (or method).
+
+    This helper should only be used at class scope, as follows::
+
+        class Foo:
+            attr = _deprecate_privatize_attribute(*args, **kwargs)
+
+    where *all* parameters are forwarded to `deprecated`.  This form makes
+    ``attr`` a property which forwards read and write access to ``self._attr``
+    (same name but with a leading underscore), with a deprecation warning.
+    Note that the attribute name is derived from *the name this helper is
+    assigned to*.  This helper also works for deprecating methods.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.deprecator = deprecated(*args, **kwargs)
+
+    def __set_name__(self, owner, name):
+        setattr(owner, name, self.deprecator(
+            property(lambda self: getattr(self, f"_{name}"),
+                     lambda self, value: setattr(self, f"_{name}", value)),
+            name=name))
+
+
+# Used by _copy_docstring_and_deprecators to redecorate pyplot wrappers and
+# boilerplate.py to retrieve original signatures.  It may seem natural to store
+# this information as an attribute on the wrapper, but if the wrapper gets
+# itself functools.wraps()ed, then such attributes are silently propagated to
+# the outer wrapper, which is not desired.
+DECORATORS = {}
+
+
+def rename_parameter(since, old, new, func=None):
+    """
+    Decorator indicating that parameter *old* of *func* is renamed to *new*.
+
+    The actual implementation of *func* should use *new*, not *old*.  If *old*
+    is passed to *func*, a DeprecationWarning is emitted, and its value is
+    used, even if *new* is also passed by keyword (this is to simplify pyplot
+    wrapper functions, which always pass *new* explicitly to the Axes method).
+    If *new* is also passed but positionally, a TypeError will be raised by the
+    underlying function during argument binding.
+
+    Examples
+    --------
+    ::
+
+        @_api.rename_parameter("3.1", "bad_name", "good_name")
+        def func(good_name): ...
+    """
+
+    decorator = functools.partial(rename_parameter, since, old, new)
+
+    if func is None:
+        return decorator
+
+    signature = inspect.signature(func)
+    assert old not in signature.parameters, (
+        f"Matplotlib internal error: {old!r} cannot be a parameter for "
+        f"{func.__name__}()")
+    assert new in signature.parameters, (
+        f"Matplotlib internal error: {new!r} must be a parameter for "
+        f"{func.__name__}()")
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        if old in kwargs:
+            warn_deprecated(
+                since, message=f"The {old!r} parameter of {func.__name__}() "
+                f"has been renamed {new!r} since Matplotlib {since}; support "
+                f"for the old name will be dropped %(removal)s.")
+            kwargs[new] = kwargs.pop(old)
+        return func(*args, **kwargs)
+
+    # wrapper() must keep the same documented signature as func(): if we
+    # instead made both *old* and *new* appear in wrapper()'s signature, they
+    # would both show up in the pyplot function for an Axes method as well and
+    # pyplot would explicitly pass both arguments to the Axes method.
+
+    DECORATORS[wrapper] = decorator
+    return wrapper
+
+
+class _deprecated_parameter_class:
+    def __repr__(self):
+        return "<deprecated parameter>"
+
+
+_deprecated_parameter = _deprecated_parameter_class()
+
+
+def delete_parameter(since, name, func=None, **kwargs):
+    """
+    Decorator indicating that parameter *name* of *func* is being deprecated.
+
+    The actual implementation of *func* should keep the *name* parameter in its
+    signature, or accept a ``**kwargs`` argument (through which *name* would be
+    passed).
+
+    Parameters that come after the deprecated parameter effectively become
+    keyword-only (as they cannot be passed positionally without triggering the
+    DeprecationWarning on the deprecated parameter), and should be marked as
+    such after the deprecation period has passed and the deprecated parameter
+    is removed.
+
+    Parameters other than *since*, *name*, and *func* are keyword-only and
+    forwarded to `.warn_deprecated`.
+
+    Examples
+    --------
+    ::
+
+        @_api.delete_parameter("3.1", "unused")
+        def func(used_arg, other_arg, unused, more_args): ...
+    """
+
+    decorator = functools.partial(delete_parameter, since, name, **kwargs)
+
+    if func is None:
+        return decorator
+
+    signature = inspect.signature(func)
+    # Name of `**kwargs` parameter of the decorated function, typically
+    # "kwargs" if such a parameter exists, or None if the decorated function
+    # doesn't accept `**kwargs`.
+    kwargs_name = next((param.name for param in signature.parameters.values()
+                        if param.kind == inspect.Parameter.VAR_KEYWORD), None)
+    if name in signature.parameters:
+        kind = signature.parameters[name].kind
+        is_varargs = kind is inspect.Parameter.VAR_POSITIONAL
+        is_varkwargs = kind is inspect.Parameter.VAR_KEYWORD
+        if not is_varargs and not is_varkwargs:
+            name_idx = (
+                # Deprecated parameter can't be passed positionally.
+                math.inf if kind is inspect.Parameter.KEYWORD_ONLY
+                # If call site has no more than this number of parameters, the
+                # deprecated parameter can't have been passed positionally.
+                else [*signature.parameters].index(name))
+            func.__signature__ = signature = signature.replace(parameters=[
+                param.replace(default=_deprecated_parameter)
+                if param.name == name else param
+                for param in signature.parameters.values()])
+        else:
+            name_idx = -1  # Deprecated parameter can always have been passed.
+    else:
+        is_varargs = is_varkwargs = False
+        # Deprecated parameter can't be passed positionally.
+        name_idx = math.inf
+        assert kwargs_name, (
+            f"Matplotlib internal error: {name!r} must be a parameter for "
+            f"{func.__name__}()")
+
+    addendum = kwargs.pop('addendum', None)
+
+    @functools.wraps(func)
+    def wrapper(*inner_args, **inner_kwargs):
+        if len(inner_args) <= name_idx and name not in inner_kwargs:
+            # Early return in the simple, non-deprecated case (much faster than
+            # calling bind()).
+            return func(*inner_args, **inner_kwargs)
+        arguments = signature.bind(*inner_args, **inner_kwargs).arguments
+        if is_varargs and arguments.get(name):
+            warn_deprecated(
+                since, message=f"Additional positional arguments to "
+                f"{func.__name__}() are deprecated since %(since)s and "
+                f"support for them will be removed %(removal)s.")
+        elif is_varkwargs and arguments.get(name):
+            warn_deprecated(
+                since, message=f"Additional keyword arguments to "
+                f"{func.__name__}() are deprecated since %(since)s and "
+                f"support for them will be removed %(removal)s.")
+        # We cannot just check `name not in arguments` because the pyplot
+        # wrappers always pass all arguments explicitly.
+        elif any(name in d and d[name] != _deprecated_parameter
+                 for d in [arguments, arguments.get(kwargs_name, {})]):
+            deprecation_addendum = (
+                f"If any parameter follows {name!r}, they should be passed as "
+                f"keyword, not positionally.")
+            warn_deprecated(
+                since,
+                name=repr(name),
+                obj_type=f"parameter of {func.__name__}()",
+                addendum=(addendum + " " + deprecation_addendum) if addendum
+                         else deprecation_addendum,
+                **kwargs)
+        return func(*inner_args, **inner_kwargs)
+
+    DECORATORS[wrapper] = decorator
+    return wrapper
+
+
+def make_keyword_only(since, name, func=None):
+    """
+    Decorator indicating that passing parameter *name* (or any of the following
+    ones) positionally to *func* is being deprecated.
+
+    When used on a method that has a pyplot wrapper, this should be the
+    outermost decorator, so that :file:`boilerplate.py` can access the original
+    signature.
+    """
+
+    decorator = functools.partial(make_keyword_only, since, name)
+
+    if func is None:
+        return decorator
+
+    signature = inspect.signature(func)
+    POK = inspect.Parameter.POSITIONAL_OR_KEYWORD
+    KWO = inspect.Parameter.KEYWORD_ONLY
+    assert (name in signature.parameters
+            and signature.parameters[name].kind == POK), (
+        f"Matplotlib internal error: {name!r} must be a positional-or-keyword "
+        f"parameter for {func.__name__}()")
+    names = [*signature.parameters]
+    name_idx = names.index(name)
+    kwonly = [name for name in names[name_idx:]
+              if signature.parameters[name].kind == POK]
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        # Don't use signature.bind here, as it would fail when stacked with
+        # rename_parameter and an "old" argument name is passed in
+        # (signature.bind would fail, but the actual call would succeed).
+        if len(args) > name_idx:
+            warn_deprecated(
+                since, message="Passing the %(name)s %(obj_type)s "
+                "positionally is deprecated since Matplotlib %(since)s; the "
+                "parameter will become keyword-only %(removal)s.",
+                name=name, obj_type=f"parameter of {func.__name__}()")
+        return func(*args, **kwargs)
+
+    # Don't modify *func*'s signature, as boilerplate.py needs it.
+    wrapper.__signature__ = signature.replace(parameters=[
+        param.replace(kind=KWO) if param.name in kwonly else param
+        for param in signature.parameters.values()])
+    DECORATORS[wrapper] = decorator
+    return wrapper
+
+
+def deprecate_method_override(method, obj, *, allow_empty=False, **kwargs):
+    """
+    Return ``obj.method`` with a deprecation if it was overridden, else None.
+
+    Parameters
+    ----------
+    method
+        An unbound method, i.e. an expression of the form
+        ``Class.method_name``.  Remember that within the body of a method, one
+        can always use ``__class__`` to refer to the class that is currently
+        being defined.
+    obj
+        Either an object of the class where *method* is defined, or a subclass
+        of that class.
+    allow_empty : bool, default: False
+        Whether to allow overrides by "empty" methods without emitting a
+        warning.
+    **kwargs
+        Additional parameters passed to `warn_deprecated` to generate the
+        deprecation warning; must at least include the "since" key.
+    """
+
+    def empty(): pass
+    def empty_with_docstring(): """doc"""
+
+    name = method.__name__
+    bound_child = getattr(obj, name)
+    bound_base = (
+        method  # If obj is a class, then we need to use unbound methods.
+        if isinstance(bound_child, type(empty)) and isinstance(obj, type)
+        else method.__get__(obj))
+    if (bound_child != bound_base
+            and (not allow_empty
+                 or (getattr(getattr(bound_child, "__code__", None),
+                             "co_code", None)
+                     not in [empty.__code__.co_code,
+                             empty_with_docstring.__code__.co_code]))):
+        warn_deprecated(**{"name": name, "obj_type": "method", **kwargs})
+        return bound_child
+    return None
+
+
+@contextlib.contextmanager
+def suppress_matplotlib_deprecation_warning():
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", MatplotlibDeprecationWarning)
+        yield

llava_next/lib/python3.10/site-packages/matplotlib/_api/deprecation.pyi

@@ -0,0 +1,76 @@
+from collections.abc import Callable
+import contextlib
+from typing import Any, TypedDict, TypeVar, overload
+from typing_extensions import (
+    ParamSpec,  # < Py 3.10
+    Unpack,  # < Py 3.11
+)
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+_T = TypeVar("_T")
+
+class MatplotlibDeprecationWarning(DeprecationWarning): ...
+
+class DeprecationKwargs(TypedDict, total=False):
+    message: str
+    alternative: str
+    pending: bool
+    obj_type: str
+    addendum: str
+    removal: str
+
+class NamedDeprecationKwargs(DeprecationKwargs, total=False):
+    name: str
+
+def warn_deprecated(since: str, **kwargs: Unpack[NamedDeprecationKwargs]) -> None: ...
+def deprecated(
+    since: str, **kwargs: Unpack[NamedDeprecationKwargs]
+) -> Callable[[_T], _T]: ...
+
+class deprecate_privatize_attribute(Any):
+    def __init__(self, since: str, **kwargs: Unpack[NamedDeprecationKwargs]): ...
+    def __set_name__(self, owner: type[object], name: str) -> None: ...
+
+DECORATORS: dict[Callable, Callable] = ...
+
+@overload
+def rename_parameter(
+    since: str, old: str, new: str, func: None = ...
+) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: ...
+@overload
+def rename_parameter(
+    since: str, old: str, new: str, func: Callable[_P, _R]
+) -> Callable[_P, _R]: ...
+
+class _deprecated_parameter_class: ...
+
+_deprecated_parameter: _deprecated_parameter_class
+
+@overload
+def delete_parameter(
+    since: str, name: str, func: None = ..., **kwargs: Unpack[DeprecationKwargs]
+) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: ...
+@overload
+def delete_parameter(
+    since: str, name: str, func: Callable[_P, _R], **kwargs: Unpack[DeprecationKwargs]
+) -> Callable[_P, _R]: ...
+@overload
+def make_keyword_only(
+    since: str, name: str, func: None = ...
+) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: ...
+@overload
+def make_keyword_only(
+    since: str, name: str, func: Callable[_P, _R]
+) -> Callable[_P, _R]: ...
+def deprecate_method_override(
+    method: Callable[_P, _R],
+    obj: object | type,
+    *,
+    allow_empty: bool = ...,
+    since: str,
+    **kwargs: Unpack[NamedDeprecationKwargs]
+) -> Callable[_P, _R]: ...
+def suppress_matplotlib_deprecation_warning() -> (
+    contextlib.AbstractContextManager[None]
+): ...

llava_next/lib/python3.10/site-packages/matplotlib/_blocking_input.py

@@ -0,0 +1,30 @@
+def blocking_input_loop(figure, event_names, timeout, handler):
+    """
+    Run *figure*'s event loop while listening to interactive events.
+
+    The events listed in *event_names* are passed to *handler*.
+
+    This function is used to implement `.Figure.waitforbuttonpress`,
+    `.Figure.ginput`, and `.Axes.clabel`.
+
+    Parameters
+    ----------
+    figure : `~matplotlib.figure.Figure`
+    event_names : list of str
+        The names of the events passed to *handler*.
+    timeout : float
+        If positive, the event loop is stopped after *timeout* seconds.
+    handler : Callable[[Event], Any]
+        Function called for each event; it can force an early exit of the event
+        loop by calling ``canvas.stop_event_loop()``.
+    """
+    if figure.canvas.manager:
+        figure.show()  # Ensure that the figure is shown if we are managing it.
+    # Connect the events to the on_event function call.
+    cids = [figure.canvas.mpl_connect(name, handler) for name in event_names]
+    try:
+        figure.canvas.start_event_loop(timeout)  # Start event loop.
+    finally:  # Run even on exception like ctrl-c.
+        # Disconnect the callbacks.
+        for cid in cids:
+            figure.canvas.mpl_disconnect(cid)

llava_next/lib/python3.10/site-packages/matplotlib/_cm.py

@@ -0,0 +1,1446 @@
+"""
+Nothing here but dictionaries for generating LinearSegmentedColormaps,
+and a dictionary of these dictionaries.
+
+Documentation for each is in pyplot.colormaps().  Please update this
+with the purpose and type of your colormap if you add data for one here.
+"""
+
+from functools import partial
+
+import numpy as np
+
+_binary_data = {
+    'red':    ((0., 1., 1.), (1., 0., 0.)),
+    'green':  ((0., 1., 1.), (1., 0., 0.)),
+    'blue':   ((0., 1., 1.), (1., 0., 0.))
+    }
+
+_autumn_data = {'red':   ((0., 1.0, 1.0), (1.0, 1.0, 1.0)),
+                'green': ((0., 0., 0.), (1.0, 1.0, 1.0)),
+                'blue':  ((0., 0., 0.), (1.0, 0., 0.))}
+
+_bone_data = {'red':   ((0., 0., 0.),
+                        (0.746032, 0.652778, 0.652778),
+                        (1.0, 1.0, 1.0)),
+              'green': ((0., 0., 0.),
+                        (0.365079, 0.319444, 0.319444),
+                        (0.746032, 0.777778, 0.777778),
+                        (1.0, 1.0, 1.0)),
+              'blue':  ((0., 0., 0.),
+                        (0.365079, 0.444444, 0.444444),
+                        (1.0, 1.0, 1.0))}
+
+_cool_data = {'red':   ((0., 0., 0.), (1.0, 1.0, 1.0)),
+              'green': ((0., 1., 1.), (1.0, 0.,  0.)),
+              'blue':  ((0., 1., 1.), (1.0, 1.,  1.))}
+
+_copper_data = {'red':   ((0., 0., 0.),
+                          (0.809524, 1.000000, 1.000000),
+                          (1.0, 1.0, 1.0)),
+                'green': ((0., 0., 0.),
+                          (1.0, 0.7812, 0.7812)),
+                'blue':  ((0., 0., 0.),
+                          (1.0, 0.4975, 0.4975))}
+
+def _flag_red(x): return 0.75 * np.sin((x * 31.5 + 0.25) * np.pi) + 0.5
+def _flag_green(x): return np.sin(x * 31.5 * np.pi)
+def _flag_blue(x): return 0.75 * np.sin((x * 31.5 - 0.25) * np.pi) + 0.5
+_flag_data = {'red': _flag_red, 'green': _flag_green, 'blue': _flag_blue}
+
+def _prism_red(x): return 0.75 * np.sin((x * 20.9 + 0.25) * np.pi) + 0.67
+def _prism_green(x): return 0.75 * np.sin((x * 20.9 - 0.25) * np.pi) + 0.33
+def _prism_blue(x): return -1.1 * np.sin((x * 20.9) * np.pi)
+_prism_data = {'red': _prism_red, 'green': _prism_green, 'blue': _prism_blue}
+
+def _ch_helper(gamma, s, r, h, p0, p1, x):
+    """Helper function for generating picklable cubehelix colormaps."""
+    # Apply gamma factor to emphasise low or high intensity values
+    xg = x ** gamma
+    # Calculate amplitude and angle of deviation from the black to white
+    # diagonal in the plane of constant perceived intensity.
+    a = h * xg * (1 - xg) / 2
+    phi = 2 * np.pi * (s / 3 + r * x)
+    return xg + a * (p0 * np.cos(phi) + p1 * np.sin(phi))
+
+def cubehelix(gamma=1.0, s=0.5, r=-1.5, h=1.0):
+    """
+    Return custom data dictionary of (r, g, b) conversion functions, which can
+    be used with `.ColormapRegistry.register`, for the cubehelix color scheme.
+
+    Unlike most other color schemes cubehelix was designed by D.A. Green to
+    be monotonically increasing in terms of perceived brightness.
+    Also, when printed on a black and white postscript printer, the scheme
+    results in a greyscale with monotonically increasing brightness.
+    This color scheme is named cubehelix because the (r, g, b) values produced
+    can be visualised as a squashed helix around the diagonal in the
+    (r, g, b) color cube.
+
+    For a unit color cube (i.e. 3D coordinates for (r, g, b) each in the
+    range 0 to 1) the color scheme starts at (r, g, b) = (0, 0, 0), i.e. black,
+    and finishes at (r, g, b) = (1, 1, 1), i.e. white. For some fraction *x*,
+    between 0 and 1, the color is the corresponding grey value at that
+    fraction along the black to white diagonal (x, x, x) plus a color
+    element. This color element is calculated in a plane of constant
+    perceived intensity and controlled by the following parameters.
+
+    Parameters
+    ----------
+    gamma : float, default: 1
+        Gamma factor emphasizing either low intensity values (gamma < 1), or
+        high intensity values (gamma > 1).
+    s : float, default: 0.5 (purple)
+        The starting color.
+    r : float, default: -1.5
+        The number of r, g, b rotations in color that are made from the start
+        to the end of the color scheme.  The default of -1.5 corresponds to ->
+        B -> G -> R -> B.
+    h : float, default: 1
+        The hue, i.e. how saturated the colors are. If this parameter is zero
+        then the color scheme is purely a greyscale.
+    """
+    return {'red': partial(_ch_helper, gamma, s, r, h, -0.14861, 1.78277),
+            'green': partial(_ch_helper, gamma, s, r, h, -0.29227, -0.90649),
+            'blue': partial(_ch_helper, gamma, s, r, h, 1.97294, 0.0)}
+
+_cubehelix_data = cubehelix()
+
+_bwr_data = ((0.0, 0.0, 1.0), (1.0, 1.0, 1.0), (1.0, 0.0, 0.0))
+_brg_data = ((0.0, 0.0, 1.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0))
+
+# Gnuplot palette functions
+def _g0(x): return 0
+def _g1(x): return 0.5
+def _g2(x): return 1
+def _g3(x): return x
+def _g4(x): return x ** 2
+def _g5(x): return x ** 3
+def _g6(x): return x ** 4
+def _g7(x): return np.sqrt(x)
+def _g8(x): return np.sqrt(np.sqrt(x))
+def _g9(x): return np.sin(x * np.pi / 2)
+def _g10(x): return np.cos(x * np.pi / 2)
+def _g11(x): return np.abs(x - 0.5)
+def _g12(x): return (2 * x - 1) ** 2
+def _g13(x): return np.sin(x * np.pi)
+def _g14(x): return np.abs(np.cos(x * np.pi))
+def _g15(x): return np.sin(x * 2 * np.pi)
+def _g16(x): return np.cos(x * 2 * np.pi)
+def _g17(x): return np.abs(np.sin(x * 2 * np.pi))
+def _g18(x): return np.abs(np.cos(x * 2 * np.pi))
+def _g19(x): return np.abs(np.sin(x * 4 * np.pi))
+def _g20(x): return np.abs(np.cos(x * 4 * np.pi))
+def _g21(x): return 3 * x
+def _g22(x): return 3 * x - 1
+def _g23(x): return 3 * x - 2
+def _g24(x): return np.abs(3 * x - 1)
+def _g25(x): return np.abs(3 * x - 2)
+def _g26(x): return (3 * x - 1) / 2
+def _g27(x): return (3 * x - 2) / 2
+def _g28(x): return np.abs((3 * x - 1) / 2)
+def _g29(x): return np.abs((3 * x - 2) / 2)
+def _g30(x): return x / 0.32 - 0.78125
+def _g31(x): return 2 * x - 0.84
+def _g32(x):
+    ret = np.zeros(len(x))
+    m = (x < 0.25)
+    ret[m] = 4 * x[m]
+    m = (x >= 0.25) & (x < 0.92)
+    ret[m] = -2 * x[m] + 1.84
+    m = (x >= 0.92)
+    ret[m] = x[m] / 0.08 - 11.5
+    return ret
+def _g33(x): return np.abs(2 * x - 0.5)
+def _g34(x): return 2 * x
+def _g35(x): return 2 * x - 0.5
+def _g36(x): return 2 * x - 1
+
+gfunc = {i: globals()[f"_g{i}"] for i in range(37)}
+
+_gnuplot_data = {
+        'red': gfunc[7],
+        'green': gfunc[5],
+        'blue': gfunc[15],
+}
+
+_gnuplot2_data = {
+        'red': gfunc[30],
+        'green': gfunc[31],
+        'blue': gfunc[32],
+}
+
+_ocean_data = {
+        'red': gfunc[23],
+        'green': gfunc[28],
+        'blue': gfunc[3],
+}
+
+_afmhot_data = {
+        'red': gfunc[34],
+        'green': gfunc[35],
+        'blue': gfunc[36],
+}
+
+_rainbow_data = {
+        'red': gfunc[33],
+        'green': gfunc[13],
+        'blue': gfunc[10],
+}
+
+_seismic_data = (
+        (0.0, 0.0, 0.3), (0.0, 0.0, 1.0),
+        (1.0, 1.0, 1.0), (1.0, 0.0, 0.0),
+        (0.5, 0.0, 0.0))
+
+_terrain_data = (
+        (0.00, (0.2, 0.2, 0.6)),
+        (0.15, (0.0, 0.6, 1.0)),
+        (0.25, (0.0, 0.8, 0.4)),
+        (0.50, (1.0, 1.0, 0.6)),
+        (0.75, (0.5, 0.36, 0.33)),
+        (1.00, (1.0, 1.0, 1.0)))
+
+_gray_data = {'red':   ((0., 0, 0), (1., 1, 1)),
+              'green': ((0., 0, 0), (1., 1, 1)),
+              'blue':  ((0., 0, 0), (1., 1, 1))}
+
+_hot_data = {'red':   ((0., 0.0416, 0.0416),
+                       (0.365079, 1.000000, 1.000000),
+                       (1.0, 1.0, 1.0)),
+             'green': ((0., 0., 0.),
+                       (0.365079, 0.000000, 0.000000),
+                       (0.746032, 1.000000, 1.000000),
+                       (1.0, 1.0, 1.0)),
+             'blue':  ((0., 0., 0.),
+                       (0.746032, 0.000000, 0.000000),
+                       (1.0, 1.0, 1.0))}
+
+_hsv_data = {'red':   ((0., 1., 1.),
+                       (0.158730, 1.000000, 1.000000),
+                       (0.174603, 0.968750, 0.968750),
+                       (0.333333, 0.031250, 0.031250),
+                       (0.349206, 0.000000, 0.000000),
+                       (0.666667, 0.000000, 0.000000),
+                       (0.682540, 0.031250, 0.031250),
+                       (0.841270, 0.968750, 0.968750),
+                       (0.857143, 1.000000, 1.000000),
+                       (1.0, 1.0, 1.0)),
+             'green': ((0., 0., 0.),
+                       (0.158730, 0.937500, 0.937500),
+                       (0.174603, 1.000000, 1.000000),
+                       (0.507937, 1.000000, 1.000000),
+                       (0.666667, 0.062500, 0.062500),
+                       (0.682540, 0.000000, 0.000000),
+                       (1.0, 0., 0.)),
+             'blue':  ((0., 0., 0.),
+                       (0.333333, 0.000000, 0.000000),
+                       (0.349206, 0.062500, 0.062500),
+                       (0.507937, 1.000000, 1.000000),
+                       (0.841270, 1.000000, 1.000000),
+                       (0.857143, 0.937500, 0.937500),
+                       (1.0, 0.09375, 0.09375))}
+
+_jet_data = {'red':   ((0.00, 0, 0),
+                       (0.35, 0, 0),
+                       (0.66, 1, 1),
+                       (0.89, 1, 1),
+                       (1.00, 0.5, 0.5)),
+             'green': ((0.000, 0, 0),
+                       (0.125, 0, 0),
+                       (0.375, 1, 1),
+                       (0.640, 1, 1),
+                       (0.910, 0, 0),
+                       (1.000, 0, 0)),
+             'blue':  ((0.00, 0.5, 0.5),
+                       (0.11, 1, 1),
+                       (0.34, 1, 1),
+                       (0.65, 0, 0),
+                       (1.00, 0, 0))}
+
+_pink_data = {'red':   ((0., 0.1178, 0.1178), (0.015873, 0.195857, 0.195857),
+                        (0.031746, 0.250661, 0.250661),
+                        (0.047619, 0.295468, 0.295468),
+                        (0.063492, 0.334324, 0.334324),
+                        (0.079365, 0.369112, 0.369112),
+                        (0.095238, 0.400892, 0.400892),
+                        (0.111111, 0.430331, 0.430331),
+                        (0.126984, 0.457882, 0.457882),
+                        (0.142857, 0.483867, 0.483867),
+                        (0.158730, 0.508525, 0.508525),
+                        (0.174603, 0.532042, 0.532042),
+                        (0.190476, 0.554563, 0.554563),
+                        (0.206349, 0.576204, 0.576204),
+                        (0.222222, 0.597061, 0.597061),
+                        (0.238095, 0.617213, 0.617213),
+                        (0.253968, 0.636729, 0.636729),
+                        (0.269841, 0.655663, 0.655663),
+                        (0.285714, 0.674066, 0.674066),
+                        (0.301587, 0.691980, 0.691980),
+                        (0.317460, 0.709441, 0.709441),
+                        (0.333333, 0.726483, 0.726483),
+                        (0.349206, 0.743134, 0.743134),
+                        (0.365079, 0.759421, 0.759421),
+                        (0.380952, 0.766356, 0.766356),
+                        (0.396825, 0.773229, 0.773229),
+                        (0.412698, 0.780042, 0.780042),
+                        (0.428571, 0.786796, 0.786796),
+                        (0.444444, 0.793492, 0.793492),
+                        (0.460317, 0.800132, 0.800132),
+                        (0.476190, 0.806718, 0.806718),
+                        (0.492063, 0.813250, 0.813250),
+                        (0.507937, 0.819730, 0.819730),
+                        (0.523810, 0.826160, 0.826160),
+                        (0.539683, 0.832539, 0.832539),
+                        (0.555556, 0.838870, 0.838870),
+                        (0.571429, 0.845154, 0.845154),
+                        (0.587302, 0.851392, 0.851392),
+                        (0.603175, 0.857584, 0.857584),
+                        (0.619048, 0.863731, 0.863731),
+                        (0.634921, 0.869835, 0.869835),
+                        (0.650794, 0.875897, 0.875897),
+                        (0.666667, 0.881917, 0.881917),
+                        (0.682540, 0.887896, 0.887896),
+                        (0.698413, 0.893835, 0.893835),
+                        (0.714286, 0.899735, 0.899735),
+                        (0.730159, 0.905597, 0.905597),
+                        (0.746032, 0.911421, 0.911421),
+                        (0.761905, 0.917208, 0.917208),
+                        (0.777778, 0.922958, 0.922958),
+                        (0.793651, 0.928673, 0.928673),
+                        (0.809524, 0.934353, 0.934353),
+                        (0.825397, 0.939999, 0.939999),
+                        (0.841270, 0.945611, 0.945611),
+                        (0.857143, 0.951190, 0.951190),
+                        (0.873016, 0.956736, 0.956736),
+                        (0.888889, 0.962250, 0.962250),
+                        (0.904762, 0.967733, 0.967733),
+                        (0.920635, 0.973185, 0.973185),
+                        (0.936508, 0.978607, 0.978607),
+                        (0.952381, 0.983999, 0.983999),
+                        (0.968254, 0.989361, 0.989361),
+                        (0.984127, 0.994695, 0.994695), (1.0, 1.0, 1.0)),
+              'green': ((0., 0., 0.), (0.015873, 0.102869, 0.102869),
+                        (0.031746, 0.145479, 0.145479),
+                        (0.047619, 0.178174, 0.178174),
+                        (0.063492, 0.205738, 0.205738),
+                        (0.079365, 0.230022, 0.230022),
+                        (0.095238, 0.251976, 0.251976),
+                        (0.111111, 0.272166, 0.272166),
+                        (0.126984, 0.290957, 0.290957),
+                        (0.142857, 0.308607, 0.308607),
+                        (0.158730, 0.325300, 0.325300),
+                        (0.174603, 0.341178, 0.341178),
+                        (0.190476, 0.356348, 0.356348),
+                        (0.206349, 0.370899, 0.370899),
+                        (0.222222, 0.384900, 0.384900),
+                        (0.238095, 0.398410, 0.398410),
+                        (0.253968, 0.411476, 0.411476),
+                        (0.269841, 0.424139, 0.424139),
+                        (0.285714, 0.436436, 0.436436),
+                        (0.301587, 0.448395, 0.448395),
+                        (0.317460, 0.460044, 0.460044),
+                        (0.333333, 0.471405, 0.471405),
+                        (0.349206, 0.482498, 0.482498),
+                        (0.365079, 0.493342, 0.493342),
+                        (0.380952, 0.517549, 0.517549),
+                        (0.396825, 0.540674, 0.540674),
+                        (0.412698, 0.562849, 0.562849),
+                        (0.428571, 0.584183, 0.584183),
+                        (0.444444, 0.604765, 0.604765),
+                        (0.460317, 0.624669, 0.624669),
+                        (0.476190, 0.643958, 0.643958),
+                        (0.492063, 0.662687, 0.662687),
+                        (0.507937, 0.680900, 0.680900),
+                        (0.523810, 0.698638, 0.698638),
+                        (0.539683, 0.715937, 0.715937),
+                        (0.555556, 0.732828, 0.732828),
+                        (0.571429, 0.749338, 0.749338),
+                        (0.587302, 0.765493, 0.765493),
+                        (0.603175, 0.781313, 0.781313),
+                        (0.619048, 0.796819, 0.796819),
+                        (0.634921, 0.812029, 0.812029),
+                        (0.650794, 0.826960, 0.826960),
+                        (0.666667, 0.841625, 0.841625),
+                        (0.682540, 0.856040, 0.856040),
+                        (0.698413, 0.870216, 0.870216),
+                        (0.714286, 0.884164, 0.884164),
+                        (0.730159, 0.897896, 0.897896),
+                        (0.746032, 0.911421, 0.911421),
+                        (0.761905, 0.917208, 0.917208),
+                        (0.777778, 0.922958, 0.922958),
+                        (0.793651, 0.928673, 0.928673),
+                        (0.809524, 0.934353, 0.934353),
+                        (0.825397, 0.939999, 0.939999),
+                        (0.841270, 0.945611, 0.945611),
+                        (0.857143, 0.951190, 0.951190),
+                        (0.873016, 0.956736, 0.956736),
+                        (0.888889, 0.962250, 0.962250),
+                        (0.904762, 0.967733, 0.967733),
+                        (0.920635, 0.973185, 0.973185),
+                        (0.936508, 0.978607, 0.978607),
+                        (0.952381, 0.983999, 0.983999),
+                        (0.968254, 0.989361, 0.989361),
+                        (0.984127, 0.994695, 0.994695), (1.0, 1.0, 1.0)),
+              'blue':  ((0., 0., 0.), (0.015873, 0.102869, 0.102869),
+                        (0.031746, 0.145479, 0.145479),
+                        (0.047619, 0.178174, 0.178174),
+                        (0.063492, 0.205738, 0.205738),
+                        (0.079365, 0.230022, 0.230022),
+                        (0.095238, 0.251976, 0.251976),
+                        (0.111111, 0.272166, 0.272166),
+                        (0.126984, 0.290957, 0.290957),
+                        (0.142857, 0.308607, 0.308607),
+                        (0.158730, 0.325300, 0.325300),
+                        (0.174603, 0.341178, 0.341178),
+                        (0.190476, 0.356348, 0.356348),
+                        (0.206349, 0.370899, 0.370899),
+                        (0.222222, 0.384900, 0.384900),
+                        (0.238095, 0.398410, 0.398410),
+                        (0.253968, 0.411476, 0.411476),
+                        (0.269841, 0.424139, 0.424139),
+                        (0.285714, 0.436436, 0.436436),
+                        (0.301587, 0.448395, 0.448395),
+                        (0.317460, 0.460044, 0.460044),
+                        (0.333333, 0.471405, 0.471405),
+                        (0.349206, 0.482498, 0.482498),
+                        (0.365079, 0.493342, 0.493342),
+                        (0.380952, 0.503953, 0.503953),
+                        (0.396825, 0.514344, 0.514344),
+                        (0.412698, 0.524531, 0.524531),
+                        (0.428571, 0.534522, 0.534522),
+                        (0.444444, 0.544331, 0.544331),
+                        (0.460317, 0.553966, 0.553966),
+                        (0.476190, 0.563436, 0.563436),
+                        (0.492063, 0.572750, 0.572750),
+                        (0.507937, 0.581914, 0.581914),
+                        (0.523810, 0.590937, 0.590937),
+                        (0.539683, 0.599824, 0.599824),
+                        (0.555556, 0.608581, 0.608581),
+                        (0.571429, 0.617213, 0.617213),
+                        (0.587302, 0.625727, 0.625727),
+                        (0.603175, 0.634126, 0.634126),
+                        (0.619048, 0.642416, 0.642416),
+                        (0.634921, 0.650600, 0.650600),
+                        (0.650794, 0.658682, 0.658682),
+                        (0.666667, 0.666667, 0.666667),
+                        (0.682540, 0.674556, 0.674556),
+                        (0.698413, 0.682355, 0.682355),
+                        (0.714286, 0.690066, 0.690066),
+                        (0.730159, 0.697691, 0.697691),
+                        (0.746032, 0.705234, 0.705234),
+                        (0.761905, 0.727166, 0.727166),
+                        (0.777778, 0.748455, 0.748455),
+                        (0.793651, 0.769156, 0.769156),
+                        (0.809524, 0.789314, 0.789314),
+                        (0.825397, 0.808969, 0.808969),
+                        (0.841270, 0.828159, 0.828159),
+                        (0.857143, 0.846913, 0.846913),
+                        (0.873016, 0.865261, 0.865261),
+                        (0.888889, 0.883229, 0.883229),
+                        (0.904762, 0.900837, 0.900837),
+                        (0.920635, 0.918109, 0.918109),
+                        (0.936508, 0.935061, 0.935061),
+                        (0.952381, 0.951711, 0.951711),
+                        (0.968254, 0.968075, 0.968075),
+                        (0.984127, 0.984167, 0.984167), (1.0, 1.0, 1.0))}
+
+_spring_data = {'red':   ((0., 1., 1.), (1.0, 1.0, 1.0)),
+                'green': ((0., 0., 0.), (1.0, 1.0, 1.0)),
+                'blue':  ((0., 1., 1.), (1.0, 0.0, 0.0))}
+
+
+_summer_data = {'red':   ((0., 0., 0.), (1.0, 1.0, 1.0)),
+                'green': ((0., 0.5, 0.5), (1.0, 1.0, 1.0)),
+                'blue':  ((0., 0.4, 0.4), (1.0, 0.4, 0.4))}
+
+
+_winter_data = {'red':   ((0., 0., 0.), (1.0, 0.0, 0.0)),
+                'green': ((0., 0., 0.), (1.0, 1.0, 1.0)),
+                'blue':  ((0., 1., 1.), (1.0, 0.5, 0.5))}
+
+_nipy_spectral_data = {
+    'red': [
+        (0.0, 0.0, 0.0), (0.05, 0.4667, 0.4667),
+        (0.10, 0.5333, 0.5333), (0.15, 0.0, 0.0),
+        (0.20, 0.0, 0.0), (0.25, 0.0, 0.0),
+        (0.30, 0.0, 0.0), (0.35, 0.0, 0.0),
+        (0.40, 0.0, 0.0), (0.45, 0.0, 0.0),
+        (0.50, 0.0, 0.0), (0.55, 0.0, 0.0),
+        (0.60, 0.0, 0.0), (0.65, 0.7333, 0.7333),
+        (0.70, 0.9333, 0.9333), (0.75, 1.0, 1.0),
+        (0.80, 1.0, 1.0), (0.85, 1.0, 1.0),
+        (0.90, 0.8667, 0.8667), (0.95, 0.80, 0.80),
+        (1.0, 0.80, 0.80),
+    ],
+    'green': [
+        (0.0, 0.0, 0.0), (0.05, 0.0, 0.0),
+        (0.10, 0.0, 0.0), (0.15, 0.0, 0.0),
+        (0.20, 0.0, 0.0), (0.25, 0.4667, 0.4667),
+        (0.30, 0.6000, 0.6000), (0.35, 0.6667, 0.6667),
+        (0.40, 0.6667, 0.6667), (0.45, 0.6000, 0.6000),
+        (0.50, 0.7333, 0.7333), (0.55, 0.8667, 0.8667),
+        (0.60, 1.0, 1.0), (0.65, 1.0, 1.0),
+        (0.70, 0.9333, 0.9333), (0.75, 0.8000, 0.8000),
+        (0.80, 0.6000, 0.6000), (0.85, 0.0, 0.0),
+        (0.90, 0.0, 0.0), (0.95, 0.0, 0.0),
+        (1.0, 0.80, 0.80),
+    ],
+    'blue': [
+        (0.0, 0.0, 0.0), (0.05, 0.5333, 0.5333),
+        (0.10, 0.6000, 0.6000), (0.15, 0.6667, 0.6667),
+        (0.20, 0.8667, 0.8667), (0.25, 0.8667, 0.8667),
+        (0.30, 0.8667, 0.8667), (0.35, 0.6667, 0.6667),
+        (0.40, 0.5333, 0.5333), (0.45, 0.0, 0.0),
+        (0.5, 0.0, 0.0), (0.55, 0.0, 0.0),
+        (0.60, 0.0, 0.0), (0.65, 0.0, 0.0),
+        (0.70, 0.0, 0.0), (0.75, 0.0, 0.0),
+        (0.80, 0.0, 0.0), (0.85, 0.0, 0.0),
+        (0.90, 0.0, 0.0), (0.95, 0.0, 0.0),
+        (1.0, 0.80, 0.80),
+    ],
+}
+
+
+# 34 colormaps based on color specifications and designs
+# developed by Cynthia Brewer (https://colorbrewer2.org/).
+# The ColorBrewer palettes have been included under the terms
+# of an Apache-stype license (for details, see the file
+# LICENSE_COLORBREWER in the license directory of the matplotlib
+# source distribution).
+
+# RGB values taken from Brewer's Excel sheet, divided by 255
+
+_Blues_data = (
+    (0.96862745098039216,  0.98431372549019602,  1.0                ),
+    (0.87058823529411766,  0.92156862745098034,  0.96862745098039216),
+    (0.77647058823529413,  0.85882352941176465,  0.93725490196078431),
+    (0.61960784313725492,  0.792156862745098  ,  0.88235294117647056),
+    (0.41960784313725491,  0.68235294117647061,  0.83921568627450982),
+    (0.25882352941176473,  0.5725490196078431 ,  0.77647058823529413),
+    (0.12941176470588237,  0.44313725490196076,  0.70980392156862748),
+    (0.03137254901960784,  0.31764705882352939,  0.61176470588235299),
+    (0.03137254901960784,  0.18823529411764706,  0.41960784313725491)
+    )
+
+_BrBG_data = (
+    (0.32941176470588235,  0.18823529411764706,  0.0196078431372549 ),
+    (0.5490196078431373 ,  0.31764705882352939,  0.0392156862745098 ),
+    (0.74901960784313726,  0.50588235294117645,  0.17647058823529413),
+    (0.87450980392156863,  0.76078431372549016,  0.49019607843137253),
+    (0.96470588235294119,  0.90980392156862744,  0.76470588235294112),
+    (0.96078431372549022,  0.96078431372549022,  0.96078431372549022),
+    (0.7803921568627451 ,  0.91764705882352937,  0.89803921568627454),
+    (0.50196078431372548,  0.80392156862745101,  0.75686274509803919),
+    (0.20784313725490197,  0.59215686274509804,  0.5607843137254902 ),
+    (0.00392156862745098,  0.4                ,  0.36862745098039218),
+    (0.0                ,  0.23529411764705882,  0.18823529411764706)
+    )
+
+_BuGn_data = (
+    (0.96862745098039216,  0.9882352941176471 ,  0.99215686274509807),
+    (0.89803921568627454,  0.96078431372549022,  0.97647058823529409),
+    (0.8                ,  0.92549019607843142,  0.90196078431372551),
+    (0.6                ,  0.84705882352941175,  0.78823529411764703),
+    (0.4                ,  0.76078431372549016,  0.64313725490196083),
+    (0.25490196078431371,  0.68235294117647061,  0.46274509803921571),
+    (0.13725490196078433,  0.54509803921568623,  0.27058823529411763),
+    (0.0                ,  0.42745098039215684,  0.17254901960784313),
+    (0.0                ,  0.26666666666666666,  0.10588235294117647)
+    )
+
+_BuPu_data = (
+    (0.96862745098039216,  0.9882352941176471 ,  0.99215686274509807),
+    (0.8784313725490196 ,  0.92549019607843142,  0.95686274509803926),
+    (0.74901960784313726,  0.82745098039215681,  0.90196078431372551),
+    (0.61960784313725492,  0.73725490196078436,  0.85490196078431369),
+    (0.5490196078431373 ,  0.58823529411764708,  0.77647058823529413),
+    (0.5490196078431373 ,  0.41960784313725491,  0.69411764705882351),
+    (0.53333333333333333,  0.25490196078431371,  0.61568627450980395),
+    (0.50588235294117645,  0.05882352941176471,  0.48627450980392156),
+    (0.30196078431372547,  0.0                ,  0.29411764705882354)
+    )
+
+_GnBu_data = (
+    (0.96862745098039216,  0.9882352941176471 ,  0.94117647058823528),
+    (0.8784313725490196 ,  0.95294117647058818,  0.85882352941176465),
+    (0.8                ,  0.92156862745098034,  0.77254901960784317),
+    (0.6588235294117647 ,  0.8666666666666667 ,  0.70980392156862748),
+    (0.4823529411764706 ,  0.8                ,  0.7686274509803922 ),
+    (0.30588235294117649,  0.70196078431372544,  0.82745098039215681),
+    (0.16862745098039217,  0.5490196078431373 ,  0.74509803921568629),
+    (0.03137254901960784,  0.40784313725490196,  0.67450980392156867),
+    (0.03137254901960784,  0.25098039215686274,  0.50588235294117645)
+    )
+
+_Greens_data = (
+    (0.96862745098039216,  0.9882352941176471 ,  0.96078431372549022),
+    (0.89803921568627454,  0.96078431372549022,  0.8784313725490196 ),
+    (0.7803921568627451 ,  0.9137254901960784 ,  0.75294117647058822),
+    (0.63137254901960782,  0.85098039215686272,  0.60784313725490191),
+    (0.45490196078431372,  0.7686274509803922 ,  0.46274509803921571),
+    (0.25490196078431371,  0.6705882352941176 ,  0.36470588235294116),
+    (0.13725490196078433,  0.54509803921568623,  0.27058823529411763),
+    (0.0                ,  0.42745098039215684,  0.17254901960784313),
+    (0.0                ,  0.26666666666666666,  0.10588235294117647)
+    )
+
+_Greys_data = (
+    (1.0                ,  1.0                ,  1.0                ),
+    (0.94117647058823528,  0.94117647058823528,  0.94117647058823528),
+    (0.85098039215686272,  0.85098039215686272,  0.85098039215686272),
+    (0.74117647058823533,  0.74117647058823533,  0.74117647058823533),
+    (0.58823529411764708,  0.58823529411764708,  0.58823529411764708),
+    (0.45098039215686275,  0.45098039215686275,  0.45098039215686275),
+    (0.32156862745098042,  0.32156862745098042,  0.32156862745098042),
+    (0.14509803921568629,  0.14509803921568629,  0.14509803921568629),
+    (0.0                ,  0.0                ,  0.0                )
+    )
+
+_Oranges_data = (
+    (1.0                ,  0.96078431372549022,  0.92156862745098034),
+    (0.99607843137254903,  0.90196078431372551,  0.80784313725490198),
+    (0.99215686274509807,  0.81568627450980391,  0.63529411764705879),
+    (0.99215686274509807,  0.68235294117647061,  0.41960784313725491),
+    (0.99215686274509807,  0.55294117647058827,  0.23529411764705882),
+    (0.94509803921568625,  0.41176470588235292,  0.07450980392156863),
+    (0.85098039215686272,  0.28235294117647058,  0.00392156862745098),
+    (0.65098039215686276,  0.21176470588235294,  0.01176470588235294),
+    (0.49803921568627452,  0.15294117647058825,  0.01568627450980392)
+    )
+
+_OrRd_data = (
+    (1.0                ,  0.96862745098039216,  0.92549019607843142),
+    (0.99607843137254903,  0.90980392156862744,  0.78431372549019607),
+    (0.99215686274509807,  0.83137254901960789,  0.61960784313725492),
+    (0.99215686274509807,  0.73333333333333328,  0.51764705882352946),
+    (0.9882352941176471 ,  0.55294117647058827,  0.34901960784313724),
+    (0.93725490196078431,  0.396078431372549  ,  0.28235294117647058),
+    (0.84313725490196079,  0.18823529411764706,  0.12156862745098039),
+    (0.70196078431372544,  0.0                ,  0.0                ),
+    (0.49803921568627452,  0.0                ,  0.0                )
+    )
+
+_PiYG_data = (
+    (0.55686274509803924,  0.00392156862745098,  0.32156862745098042),
+    (0.77254901960784317,  0.10588235294117647,  0.49019607843137253),
+    (0.87058823529411766,  0.46666666666666667,  0.68235294117647061),
+    (0.94509803921568625,  0.71372549019607845,  0.85490196078431369),
+    (0.99215686274509807,  0.8784313725490196 ,  0.93725490196078431),
+    (0.96862745098039216,  0.96862745098039216,  0.96862745098039216),
+    (0.90196078431372551,  0.96078431372549022,  0.81568627450980391),
+    (0.72156862745098038,  0.88235294117647056,  0.52549019607843139),
+    (0.49803921568627452,  0.73725490196078436,  0.25490196078431371),
+    (0.30196078431372547,  0.5725490196078431 ,  0.12941176470588237),
+    (0.15294117647058825,  0.39215686274509803,  0.09803921568627451)
+    )
+
+_PRGn_data = (
+    (0.25098039215686274,  0.0                ,  0.29411764705882354),
+    (0.46274509803921571,  0.16470588235294117,  0.51372549019607838),
+    (0.6                ,  0.4392156862745098 ,  0.6705882352941176 ),
+    (0.76078431372549016,  0.6470588235294118 ,  0.81176470588235294),
+    (0.90588235294117647,  0.83137254901960789,  0.90980392156862744),
+    (0.96862745098039216,  0.96862745098039216,  0.96862745098039216),
+    (0.85098039215686272,  0.94117647058823528,  0.82745098039215681),
+    (0.65098039215686276,  0.85882352941176465,  0.62745098039215685),
+    (0.35294117647058826,  0.68235294117647061,  0.38039215686274508),
+    (0.10588235294117647,  0.47058823529411764,  0.21568627450980393),
+    (0.0                ,  0.26666666666666666,  0.10588235294117647)
+    )
+
+_PuBu_data = (
+    (1.0                ,  0.96862745098039216,  0.98431372549019602),
+    (0.92549019607843142,  0.90588235294117647,  0.94901960784313721),
+    (0.81568627450980391,  0.81960784313725488,  0.90196078431372551),
+    (0.65098039215686276,  0.74117647058823533,  0.85882352941176465),
+    (0.45490196078431372,  0.66274509803921566,  0.81176470588235294),
+    (0.21176470588235294,  0.56470588235294117,  0.75294117647058822),
+    (0.0196078431372549 ,  0.4392156862745098 ,  0.69019607843137254),
+    (0.01568627450980392,  0.35294117647058826,  0.55294117647058827),
+    (0.00784313725490196,  0.2196078431372549 ,  0.34509803921568627)
+    )
+
+_PuBuGn_data = (
+    (1.0                ,  0.96862745098039216,  0.98431372549019602),
+    (0.92549019607843142,  0.88627450980392153,  0.94117647058823528),
+    (0.81568627450980391,  0.81960784313725488,  0.90196078431372551),
+    (0.65098039215686276,  0.74117647058823533,  0.85882352941176465),
+    (0.40392156862745099,  0.66274509803921566,  0.81176470588235294),
+    (0.21176470588235294,  0.56470588235294117,  0.75294117647058822),
+    (0.00784313725490196,  0.50588235294117645,  0.54117647058823526),
+    (0.00392156862745098,  0.42352941176470588,  0.34901960784313724),
+    (0.00392156862745098,  0.27450980392156865,  0.21176470588235294)
+    )
+
+_PuOr_data = (
+    (0.49803921568627452,  0.23137254901960785,  0.03137254901960784),
+    (0.70196078431372544,  0.34509803921568627,  0.02352941176470588),
+    (0.8784313725490196 ,  0.50980392156862742,  0.07843137254901961),
+    (0.99215686274509807,  0.72156862745098038,  0.38823529411764707),
+    (0.99607843137254903,  0.8784313725490196 ,  0.71372549019607845),
+    (0.96862745098039216,  0.96862745098039216,  0.96862745098039216),
+    (0.84705882352941175,  0.85490196078431369,  0.92156862745098034),
+    (0.69803921568627447,  0.6705882352941176 ,  0.82352941176470584),
+    (0.50196078431372548,  0.45098039215686275,  0.67450980392156867),
+    (0.32941176470588235,  0.15294117647058825,  0.53333333333333333),
+    (0.17647058823529413,  0.0                ,  0.29411764705882354)
+    )
+
+_PuRd_data = (
+    (0.96862745098039216,  0.95686274509803926,  0.97647058823529409),
+    (0.90588235294117647,  0.88235294117647056,  0.93725490196078431),
+    (0.83137254901960789,  0.72549019607843135,  0.85490196078431369),
+    (0.78823529411764703,  0.58039215686274515,  0.7803921568627451 ),
+    (0.87450980392156863,  0.396078431372549  ,  0.69019607843137254),
+    (0.90588235294117647,  0.16078431372549021,  0.54117647058823526),
+    (0.80784313725490198,  0.07058823529411765,  0.33725490196078434),
+    (0.59607843137254901,  0.0                ,  0.2627450980392157 ),
+    (0.40392156862745099,  0.0                ,  0.12156862745098039)
+    )
+
+_Purples_data = (
+    (0.9882352941176471 ,  0.98431372549019602,  0.99215686274509807),
+    (0.93725490196078431,  0.92941176470588238,  0.96078431372549022),
+    (0.85490196078431369,  0.85490196078431369,  0.92156862745098034),
+    (0.73725490196078436,  0.74117647058823533,  0.86274509803921573),
+    (0.61960784313725492,  0.60392156862745094,  0.78431372549019607),
+    (0.50196078431372548,  0.49019607843137253,  0.72941176470588232),
+    (0.41568627450980394,  0.31764705882352939,  0.63921568627450975),
+    (0.32941176470588235,  0.15294117647058825,  0.5607843137254902 ),
+    (0.24705882352941178,  0.0                ,  0.49019607843137253)
+    )
+
+_RdBu_data = (
+    (0.40392156862745099,  0.0                ,  0.12156862745098039),
+    (0.69803921568627447,  0.09411764705882353,  0.16862745098039217),
+    (0.83921568627450982,  0.37647058823529411,  0.30196078431372547),
+    (0.95686274509803926,  0.6470588235294118 ,  0.50980392156862742),
+    (0.99215686274509807,  0.85882352941176465,  0.7803921568627451 ),
+    (0.96862745098039216,  0.96862745098039216,  0.96862745098039216),
+    (0.81960784313725488,  0.89803921568627454,  0.94117647058823528),
+    (0.5725490196078431 ,  0.77254901960784317,  0.87058823529411766),
+    (0.2627450980392157 ,  0.57647058823529407,  0.76470588235294112),
+    (0.12941176470588237,  0.4                ,  0.67450980392156867),
+    (0.0196078431372549 ,  0.18823529411764706,  0.38039215686274508)
+    )
+
+_RdGy_data = (
+    (0.40392156862745099,  0.0                ,  0.12156862745098039),
+    (0.69803921568627447,  0.09411764705882353,  0.16862745098039217),
+    (0.83921568627450982,  0.37647058823529411,  0.30196078431372547),
+    (0.95686274509803926,  0.6470588235294118 ,  0.50980392156862742),
+    (0.99215686274509807,  0.85882352941176465,  0.7803921568627451 ),
+    (1.0                ,  1.0                ,  1.0                ),
+    (0.8784313725490196 ,  0.8784313725490196 ,  0.8784313725490196 ),
+    (0.72941176470588232,  0.72941176470588232,  0.72941176470588232),
+    (0.52941176470588236,  0.52941176470588236,  0.52941176470588236),
+    (0.30196078431372547,  0.30196078431372547,  0.30196078431372547),
+    (0.10196078431372549,  0.10196078431372549,  0.10196078431372549)
+    )
+
+_RdPu_data = (
+    (1.0                ,  0.96862745098039216,  0.95294117647058818),
+    (0.99215686274509807,  0.8784313725490196 ,  0.86666666666666667),
+    (0.9882352941176471 ,  0.77254901960784317,  0.75294117647058822),
+    (0.98039215686274506,  0.62352941176470589,  0.70980392156862748),
+    (0.96862745098039216,  0.40784313725490196,  0.63137254901960782),
+    (0.86666666666666667,  0.20392156862745098,  0.59215686274509804),
+    (0.68235294117647061,  0.00392156862745098,  0.49411764705882355),
+    (0.47843137254901963,  0.00392156862745098,  0.46666666666666667),
+    (0.28627450980392155,  0.0                ,  0.41568627450980394)
+    )
+
+_RdYlBu_data = (
+    (0.6470588235294118 , 0.0                 , 0.14901960784313725),
+    (0.84313725490196079, 0.18823529411764706 , 0.15294117647058825),
+    (0.95686274509803926, 0.42745098039215684 , 0.2627450980392157 ),
+    (0.99215686274509807, 0.68235294117647061 , 0.38039215686274508),
+    (0.99607843137254903, 0.8784313725490196  , 0.56470588235294117),
+    (1.0                , 1.0                 , 0.74901960784313726),
+    (0.8784313725490196 , 0.95294117647058818 , 0.97254901960784312),
+    (0.6705882352941176 , 0.85098039215686272 , 0.9137254901960784 ),
+    (0.45490196078431372, 0.67843137254901964 , 0.81960784313725488),
+    (0.27058823529411763, 0.45882352941176469 , 0.70588235294117652),
+    (0.19215686274509805, 0.21176470588235294 , 0.58431372549019611)
+    )
+
+_RdYlGn_data = (
+    (0.6470588235294118 , 0.0                 , 0.14901960784313725),
+    (0.84313725490196079, 0.18823529411764706 , 0.15294117647058825),
+    (0.95686274509803926, 0.42745098039215684 , 0.2627450980392157 ),
+    (0.99215686274509807, 0.68235294117647061 , 0.38039215686274508),
+    (0.99607843137254903, 0.8784313725490196  , 0.54509803921568623),
+    (1.0                , 1.0                 , 0.74901960784313726),
+    (0.85098039215686272, 0.93725490196078431 , 0.54509803921568623),
+    (0.65098039215686276, 0.85098039215686272 , 0.41568627450980394),
+    (0.4                , 0.74117647058823533 , 0.38823529411764707),
+    (0.10196078431372549, 0.59607843137254901 , 0.31372549019607843),
+    (0.0                , 0.40784313725490196 , 0.21568627450980393)
+    )
+
+_Reds_data = (
+    (1.0                , 0.96078431372549022 , 0.94117647058823528),
+    (0.99607843137254903, 0.8784313725490196  , 0.82352941176470584),
+    (0.9882352941176471 , 0.73333333333333328 , 0.63137254901960782),
+    (0.9882352941176471 , 0.5725490196078431  , 0.44705882352941179),
+    (0.98431372549019602, 0.41568627450980394 , 0.29019607843137257),
+    (0.93725490196078431, 0.23137254901960785 , 0.17254901960784313),
+    (0.79607843137254897, 0.094117647058823528, 0.11372549019607843),
+    (0.6470588235294118 , 0.058823529411764705, 0.08235294117647058),
+    (0.40392156862745099, 0.0                 , 0.05098039215686274)
+    )
+
+_Spectral_data = (
+    (0.61960784313725492, 0.003921568627450980, 0.25882352941176473),
+    (0.83529411764705885, 0.24313725490196078 , 0.30980392156862746),
+    (0.95686274509803926, 0.42745098039215684 , 0.2627450980392157 ),
+    (0.99215686274509807, 0.68235294117647061 , 0.38039215686274508),
+    (0.99607843137254903, 0.8784313725490196  , 0.54509803921568623),
+    (1.0                , 1.0                 , 0.74901960784313726),
+    (0.90196078431372551, 0.96078431372549022 , 0.59607843137254901),
+    (0.6705882352941176 , 0.8666666666666667  , 0.64313725490196083),
+    (0.4                , 0.76078431372549016 , 0.6470588235294118 ),
+    (0.19607843137254902, 0.53333333333333333 , 0.74117647058823533),
+    (0.36862745098039218, 0.30980392156862746 , 0.63529411764705879)
+    )
+
+_YlGn_data = (
+    (1.0                , 1.0                 , 0.89803921568627454),
+    (0.96862745098039216, 0.9882352941176471  , 0.72549019607843135),
+    (0.85098039215686272, 0.94117647058823528 , 0.63921568627450975),
+    (0.67843137254901964, 0.8666666666666667  , 0.55686274509803924),
+    (0.47058823529411764, 0.77647058823529413 , 0.47450980392156861),
+    (0.25490196078431371, 0.6705882352941176  , 0.36470588235294116),
+    (0.13725490196078433, 0.51764705882352946 , 0.2627450980392157 ),
+    (0.0                , 0.40784313725490196 , 0.21568627450980393),
+    (0.0                , 0.27058823529411763 , 0.16078431372549021)
+    )
+
+_YlGnBu_data = (
+    (1.0                , 1.0                 , 0.85098039215686272),
+    (0.92941176470588238, 0.97254901960784312 , 0.69411764705882351),
+    (0.7803921568627451 , 0.9137254901960784  , 0.70588235294117652),
+    (0.49803921568627452, 0.80392156862745101 , 0.73333333333333328),
+    (0.25490196078431371, 0.71372549019607845 , 0.7686274509803922 ),
+    (0.11372549019607843, 0.56862745098039214 , 0.75294117647058822),
+    (0.13333333333333333, 0.36862745098039218 , 0.6588235294117647 ),
+    (0.14509803921568629, 0.20392156862745098 , 0.58039215686274515),
+    (0.03137254901960784, 0.11372549019607843 , 0.34509803921568627)
+    )
+
+_YlOrBr_data = (
+    (1.0                , 1.0                 , 0.89803921568627454),
+    (1.0                , 0.96862745098039216 , 0.73725490196078436),
+    (0.99607843137254903, 0.8901960784313725  , 0.56862745098039214),
+    (0.99607843137254903, 0.7686274509803922  , 0.30980392156862746),
+    (0.99607843137254903, 0.6                 , 0.16078431372549021),
+    (0.92549019607843142, 0.4392156862745098  , 0.07843137254901961),
+    (0.8                , 0.29803921568627451 , 0.00784313725490196),
+    (0.6                , 0.20392156862745098 , 0.01568627450980392),
+    (0.4                , 0.14509803921568629 , 0.02352941176470588)
+    )
+
+_YlOrRd_data = (
+    (1.0                , 1.0                 , 0.8                ),
+    (1.0                , 0.92941176470588238 , 0.62745098039215685),
+    (0.99607843137254903, 0.85098039215686272 , 0.46274509803921571),
+    (0.99607843137254903, 0.69803921568627447 , 0.29803921568627451),
+    (0.99215686274509807, 0.55294117647058827 , 0.23529411764705882),
+    (0.9882352941176471 , 0.30588235294117649 , 0.16470588235294117),
+    (0.8901960784313725 , 0.10196078431372549 , 0.10980392156862745),
+    (0.74117647058823533, 0.0                 , 0.14901960784313725),
+    (0.50196078431372548, 0.0                 , 0.14901960784313725)
+    )
+
+
+# ColorBrewer's qualitative maps, implemented using ListedColormap
+# for use with mpl.colors.NoNorm
+
+_Accent_data = (
+    (0.49803921568627452, 0.78823529411764703, 0.49803921568627452),
+    (0.74509803921568629, 0.68235294117647061, 0.83137254901960789),
+    (0.99215686274509807, 0.75294117647058822, 0.52549019607843139),
+    (1.0,                 1.0,                 0.6                ),
+    (0.2196078431372549,  0.42352941176470588, 0.69019607843137254),
+    (0.94117647058823528, 0.00784313725490196, 0.49803921568627452),
+    (0.74901960784313726, 0.35686274509803922, 0.09019607843137254),
+    (0.4,                 0.4,                 0.4                ),
+    )
+
+_Dark2_data = (
+    (0.10588235294117647, 0.61960784313725492, 0.46666666666666667),
+    (0.85098039215686272, 0.37254901960784315, 0.00784313725490196),
+    (0.45882352941176469, 0.4392156862745098,  0.70196078431372544),
+    (0.90588235294117647, 0.16078431372549021, 0.54117647058823526),
+    (0.4,                 0.65098039215686276, 0.11764705882352941),
+    (0.90196078431372551, 0.6705882352941176,  0.00784313725490196),
+    (0.65098039215686276, 0.46274509803921571, 0.11372549019607843),
+    (0.4,                 0.4,                 0.4                ),
+    )
+
+_Paired_data = (
+    (0.65098039215686276, 0.80784313725490198, 0.8901960784313725 ),
+    (0.12156862745098039, 0.47058823529411764, 0.70588235294117652),
+    (0.69803921568627447, 0.87450980392156863, 0.54117647058823526),
+    (0.2,                 0.62745098039215685, 0.17254901960784313),
+    (0.98431372549019602, 0.60392156862745094, 0.6                ),
+    (0.8901960784313725,  0.10196078431372549, 0.10980392156862745),
+    (0.99215686274509807, 0.74901960784313726, 0.43529411764705883),
+    (1.0,                 0.49803921568627452, 0.0                ),
+    (0.792156862745098,   0.69803921568627447, 0.83921568627450982),
+    (0.41568627450980394, 0.23921568627450981, 0.60392156862745094),
+    (1.0,                 1.0,                 0.6                ),
+    (0.69411764705882351, 0.34901960784313724, 0.15686274509803921),
+    )
+
+_Pastel1_data = (
+    (0.98431372549019602, 0.70588235294117652, 0.68235294117647061),
+    (0.70196078431372544, 0.80392156862745101, 0.8901960784313725 ),
+    (0.8,                 0.92156862745098034, 0.77254901960784317),
+    (0.87058823529411766, 0.79607843137254897, 0.89411764705882357),
+    (0.99607843137254903, 0.85098039215686272, 0.65098039215686276),
+    (1.0,                 1.0,                 0.8                ),
+    (0.89803921568627454, 0.84705882352941175, 0.74117647058823533),
+    (0.99215686274509807, 0.85490196078431369, 0.92549019607843142),
+    (0.94901960784313721, 0.94901960784313721, 0.94901960784313721),
+    )
+
+_Pastel2_data = (
+    (0.70196078431372544, 0.88627450980392153, 0.80392156862745101),
+    (0.99215686274509807, 0.80392156862745101, 0.67450980392156867),
+    (0.79607843137254897, 0.83529411764705885, 0.90980392156862744),
+    (0.95686274509803926, 0.792156862745098,   0.89411764705882357),
+    (0.90196078431372551, 0.96078431372549022, 0.78823529411764703),
+    (1.0,                 0.94901960784313721, 0.68235294117647061),
+    (0.94509803921568625, 0.88627450980392153, 0.8                ),
+    (0.8,                 0.8,                 0.8                ),
+    )
+
+_Set1_data = (
+    (0.89411764705882357, 0.10196078431372549, 0.10980392156862745),
+    (0.21568627450980393, 0.49411764705882355, 0.72156862745098038),
+    (0.30196078431372547, 0.68627450980392157, 0.29019607843137257),
+    (0.59607843137254901, 0.30588235294117649, 0.63921568627450975),
+    (1.0,                 0.49803921568627452, 0.0                ),
+    (1.0,                 1.0,                 0.2                ),
+    (0.65098039215686276, 0.33725490196078434, 0.15686274509803921),
+    (0.96862745098039216, 0.50588235294117645, 0.74901960784313726),
+    (0.6,                 0.6,                 0.6),
+    )
+
+_Set2_data = (
+    (0.4,                 0.76078431372549016, 0.6470588235294118 ),
+    (0.9882352941176471,  0.55294117647058827, 0.3843137254901961 ),
+    (0.55294117647058827, 0.62745098039215685, 0.79607843137254897),
+    (0.90588235294117647, 0.54117647058823526, 0.76470588235294112),
+    (0.65098039215686276, 0.84705882352941175, 0.32941176470588235),
+    (1.0,                 0.85098039215686272, 0.18431372549019609),
+    (0.89803921568627454, 0.7686274509803922,  0.58039215686274515),
+    (0.70196078431372544, 0.70196078431372544, 0.70196078431372544),
+    )
+
+_Set3_data = (
+    (0.55294117647058827, 0.82745098039215681, 0.7803921568627451 ),
+    (1.0,                 1.0,                 0.70196078431372544),
+    (0.74509803921568629, 0.72941176470588232, 0.85490196078431369),
+    (0.98431372549019602, 0.50196078431372548, 0.44705882352941179),
+    (0.50196078431372548, 0.69411764705882351, 0.82745098039215681),
+    (0.99215686274509807, 0.70588235294117652, 0.3843137254901961 ),
+    (0.70196078431372544, 0.87058823529411766, 0.41176470588235292),
+    (0.9882352941176471,  0.80392156862745101, 0.89803921568627454),
+    (0.85098039215686272, 0.85098039215686272, 0.85098039215686272),
+    (0.73725490196078436, 0.50196078431372548, 0.74117647058823533),
+    (0.8,                 0.92156862745098034, 0.77254901960784317),
+    (1.0,                 0.92941176470588238, 0.43529411764705883),
+    )
+
+
+# The next 7 palettes are from the Yorick scientific visualization package,
+# an evolution of the GIST package, both by David H. Munro.
+# They are released under a BSD-like license (see LICENSE_YORICK in
+# the license directory of the matplotlib source distribution).
+#
+# Most palette functions have been reduced to simple function descriptions
+# by Reinier Heeres, since the rgb components were mostly straight lines.
+# gist_earth_data and gist_ncar_data were simplified by a script and some
+# manual effort.
+
+_gist_earth_data = {
+    'red': (
+        (0.0, 0.0, 0.0000),
+        (0.2824, 0.1882, 0.1882),
+        (0.4588, 0.2714, 0.2714),
+        (0.5490, 0.4719, 0.4719),
+        (0.6980, 0.7176, 0.7176),
+        (0.7882, 0.7553, 0.7553),
+        (1.0000, 0.9922, 0.9922),
+    ),
+    'green': (
+        (0.0, 0.0, 0.0000),
+        (0.0275, 0.0000, 0.0000),
+        (0.1098, 0.1893, 0.1893),
+        (0.1647, 0.3035, 0.3035),
+        (0.2078, 0.3841, 0.3841),
+        (0.2824, 0.5020, 0.5020),
+        (0.5216, 0.6397, 0.6397),
+        (0.6980, 0.7171, 0.7171),
+        (0.7882, 0.6392, 0.6392),
+        (0.7922, 0.6413, 0.6413),
+        (0.8000, 0.6447, 0.6447),
+        (0.8078, 0.6481, 0.6481),
+        (0.8157, 0.6549, 0.6549),
+        (0.8667, 0.6991, 0.6991),
+        (0.8745, 0.7103, 0.7103),
+        (0.8824, 0.7216, 0.7216),
+        (0.8902, 0.7323, 0.7323),
+        (0.8980, 0.7430, 0.7430),
+        (0.9412, 0.8275, 0.8275),
+        (0.9569, 0.8635, 0.8635),
+        (0.9647, 0.8816, 0.8816),
+        (0.9961, 0.9733, 0.9733),
+        (1.0000, 0.9843, 0.9843),
+    ),
+    'blue': (
+        (0.0, 0.0, 0.0000),
+        (0.0039, 0.1684, 0.1684),
+        (0.0078, 0.2212, 0.2212),
+        (0.0275, 0.4329, 0.4329),
+        (0.0314, 0.4549, 0.4549),
+        (0.2824, 0.5004, 0.5004),
+        (0.4667, 0.2748, 0.2748),
+        (0.5451, 0.3205, 0.3205),
+        (0.7843, 0.3961, 0.3961),
+        (0.8941, 0.6651, 0.6651),
+        (1.0000, 0.9843, 0.9843),
+    )
+}
+
+_gist_gray_data = {
+        'red': gfunc[3],
+        'green': gfunc[3],
+        'blue': gfunc[3],
+}
+
+def _gist_heat_red(x): return 1.5 * x
+def _gist_heat_green(x): return 2 * x - 1
+def _gist_heat_blue(x): return 4 * x - 3
+_gist_heat_data = {
+    'red': _gist_heat_red, 'green': _gist_heat_green, 'blue': _gist_heat_blue}
+
+_gist_ncar_data = {
+    'red': (
+        (0.0, 0.0, 0.0000),
+        (0.3098, 0.0000, 0.0000),
+        (0.3725, 0.3993, 0.3993),
+        (0.4235, 0.5003, 0.5003),
+        (0.5333, 1.0000, 1.0000),
+        (0.7922, 1.0000, 1.0000),
+        (0.8471, 0.6218, 0.6218),
+        (0.8980, 0.9235, 0.9235),
+        (1.0000, 0.9961, 0.9961),
+    ),
+    'green': (
+        (0.0, 0.0, 0.0000),
+        (0.0510, 0.3722, 0.3722),
+        (0.1059, 0.0000, 0.0000),
+        (0.1569, 0.7202, 0.7202),
+        (0.1608, 0.7537, 0.7537),
+        (0.1647, 0.7752, 0.7752),
+        (0.2157, 1.0000, 1.0000),
+        (0.2588, 0.9804, 0.9804),
+        (0.2706, 0.9804, 0.9804),
+        (0.3176, 1.0000, 1.0000),
+        (0.3686, 0.8081, 0.8081),
+        (0.4275, 1.0000, 1.0000),
+        (0.5216, 1.0000, 1.0000),
+        (0.6314, 0.7292, 0.7292),
+        (0.6863, 0.2796, 0.2796),
+        (0.7451, 0.0000, 0.0000),
+        (0.7922, 0.0000, 0.0000),
+        (0.8431, 0.1753, 0.1753),
+        (0.8980, 0.5000, 0.5000),
+        (1.0000, 0.9725, 0.9725),
+    ),
+    'blue': (
+        (0.0, 0.5020, 0.5020),
+        (0.0510, 0.0222, 0.0222),
+        (0.1098, 1.0000, 1.0000),
+        (0.2039, 1.0000, 1.0000),
+        (0.2627, 0.6145, 0.6145),
+        (0.3216, 0.0000, 0.0000),
+        (0.4157, 0.0000, 0.0000),
+        (0.4745, 0.2342, 0.2342),
+        (0.5333, 0.0000, 0.0000),
+        (0.5804, 0.0000, 0.0000),
+        (0.6314, 0.0549, 0.0549),
+        (0.6902, 0.0000, 0.0000),
+        (0.7373, 0.0000, 0.0000),
+        (0.7922, 0.9738, 0.9738),
+        (0.8000, 1.0000, 1.0000),
+        (0.8431, 1.0000, 1.0000),
+        (0.8980, 0.9341, 0.9341),
+        (1.0000, 0.9961, 0.9961),
+    )
+}
+
+_gist_rainbow_data = (
+        (0.000, (1.00, 0.00, 0.16)),
+        (0.030, (1.00, 0.00, 0.00)),
+        (0.215, (1.00, 1.00, 0.00)),
+        (0.400, (0.00, 1.00, 0.00)),
+        (0.586, (0.00, 1.00, 1.00)),
+        (0.770, (0.00, 0.00, 1.00)),
+        (0.954, (1.00, 0.00, 1.00)),
+        (1.000, (1.00, 0.00, 0.75))
+)
+
+_gist_stern_data = {
+        'red': (
+            (0.000, 0.000, 0.000), (0.0547, 1.000, 1.000),
+            (0.250, 0.027, 0.250),  # (0.2500, 0.250, 0.250),
+            (1.000, 1.000, 1.000)),
+        'green': ((0, 0, 0), (1, 1, 1)),
+        'blue': (
+            (0.000, 0.000, 0.000), (0.500, 1.000, 1.000),
+            (0.735, 0.000, 0.000), (1.000, 1.000, 1.000))
+}
+
+def _gist_yarg(x): return 1 - x
+_gist_yarg_data = {'red': _gist_yarg, 'green': _gist_yarg, 'blue': _gist_yarg}
+
+# This bipolar colormap was generated from CoolWarmFloat33.csv of
+# "Diverging Color Maps for Scientific Visualization" by Kenneth Moreland.
+# <http://www.kennethmoreland.com/color-maps/>
+_coolwarm_data = {
+    'red': [
+        (0.0, 0.2298057, 0.2298057),
+        (0.03125, 0.26623388, 0.26623388),
+        (0.0625, 0.30386891, 0.30386891),
+        (0.09375, 0.342804478, 0.342804478),
+        (0.125, 0.38301334, 0.38301334),
+        (0.15625, 0.424369608, 0.424369608),
+        (0.1875, 0.46666708, 0.46666708),
+        (0.21875, 0.509635204, 0.509635204),
+        (0.25, 0.552953156, 0.552953156),
+        (0.28125, 0.596262162, 0.596262162),
+        (0.3125, 0.639176211, 0.639176211),
+        (0.34375, 0.681291281, 0.681291281),
+        (0.375, 0.722193294, 0.722193294),
+        (0.40625, 0.761464949, 0.761464949),
+        (0.4375, 0.798691636, 0.798691636),
+        (0.46875, 0.833466556, 0.833466556),
+        (0.5, 0.865395197, 0.865395197),
+        (0.53125, 0.897787179, 0.897787179),
+        (0.5625, 0.924127593, 0.924127593),
+        (0.59375, 0.944468518, 0.944468518),
+        (0.625, 0.958852946, 0.958852946),
+        (0.65625, 0.96732803, 0.96732803),
+        (0.6875, 0.969954137, 0.969954137),
+        (0.71875, 0.966811177, 0.966811177),
+        (0.75, 0.958003065, 0.958003065),
+        (0.78125, 0.943660866, 0.943660866),
+        (0.8125, 0.923944917, 0.923944917),
+        (0.84375, 0.89904617, 0.89904617),
+        (0.875, 0.869186849, 0.869186849),
+        (0.90625, 0.834620542, 0.834620542),
+        (0.9375, 0.795631745, 0.795631745),
+        (0.96875, 0.752534934, 0.752534934),
+        (1.0, 0.705673158, 0.705673158)],
+    'green': [
+        (0.0, 0.298717966, 0.298717966),
+        (0.03125, 0.353094838, 0.353094838),
+        (0.0625, 0.406535296, 0.406535296),
+        (0.09375, 0.458757618, 0.458757618),
+        (0.125, 0.50941904, 0.50941904),
+        (0.15625, 0.558148092, 0.558148092),
+        (0.1875, 0.604562568, 0.604562568),
+        (0.21875, 0.648280772, 0.648280772),
+        (0.25, 0.688929332, 0.688929332),
+        (0.28125, 0.726149107, 0.726149107),
+        (0.3125, 0.759599947, 0.759599947),
+        (0.34375, 0.788964712, 0.788964712),
+        (0.375, 0.813952739, 0.813952739),
+        (0.40625, 0.834302879, 0.834302879),
+        (0.4375, 0.849786142, 0.849786142),
+        (0.46875, 0.860207984, 0.860207984),
+        (0.5, 0.86541021, 0.86541021),
+        (0.53125, 0.848937047, 0.848937047),
+        (0.5625, 0.827384882, 0.827384882),
+        (0.59375, 0.800927443, 0.800927443),
+        (0.625, 0.769767752, 0.769767752),
+        (0.65625, 0.734132809, 0.734132809),
+        (0.6875, 0.694266682, 0.694266682),
+        (0.71875, 0.650421156, 0.650421156),
+        (0.75, 0.602842431, 0.602842431),
+        (0.78125, 0.551750968, 0.551750968),
+        (0.8125, 0.49730856, 0.49730856),
+        (0.84375, 0.439559467, 0.439559467),
+        (0.875, 0.378313092, 0.378313092),
+        (0.90625, 0.312874446, 0.312874446),
+        (0.9375, 0.24128379, 0.24128379),
+        (0.96875, 0.157246067, 0.157246067),
+        (1.0, 0.01555616, 0.01555616)],
+    'blue': [
+        (0.0, 0.753683153, 0.753683153),
+        (0.03125, 0.801466763, 0.801466763),
+        (0.0625, 0.84495867, 0.84495867),
+        (0.09375, 0.883725899, 0.883725899),
+        (0.125, 0.917387822, 0.917387822),
+        (0.15625, 0.945619588, 0.945619588),
+        (0.1875, 0.968154911, 0.968154911),
+        (0.21875, 0.98478814, 0.98478814),
+        (0.25, 0.995375608, 0.995375608),
+        (0.28125, 0.999836203, 0.999836203),
+        (0.3125, 0.998151185, 0.998151185),
+        (0.34375, 0.990363227, 0.990363227),
+        (0.375, 0.976574709, 0.976574709),
+        (0.40625, 0.956945269, 0.956945269),
+        (0.4375, 0.931688648, 0.931688648),
+        (0.46875, 0.901068838, 0.901068838),
+        (0.5, 0.865395561, 0.865395561),
+        (0.53125, 0.820880546, 0.820880546),
+        (0.5625, 0.774508472, 0.774508472),
+        (0.59375, 0.726736146, 0.726736146),
+        (0.625, 0.678007945, 0.678007945),
+        (0.65625, 0.628751763, 0.628751763),
+        (0.6875, 0.579375448, 0.579375448),
+        (0.71875, 0.530263762, 0.530263762),
+        (0.75, 0.481775914, 0.481775914),
+        (0.78125, 0.434243684, 0.434243684),
+        (0.8125, 0.387970225, 0.387970225),
+        (0.84375, 0.343229596, 0.343229596),
+        (0.875, 0.300267182, 0.300267182),
+        (0.90625, 0.259301199, 0.259301199),
+        (0.9375, 0.220525627, 0.220525627),
+        (0.96875, 0.184115123, 0.184115123),
+        (1.0, 0.150232812, 0.150232812)]
+    }
+
+# Implementation of Carey Rappaport's CMRmap.
+# See `A Color Map for Effective Black-and-White Rendering of Color-Scale
+# Images' by Carey Rappaport
+# https://www.mathworks.com/matlabcentral/fileexchange/2662-cmrmap-m
+_CMRmap_data = {'red':    ((0.000, 0.00, 0.00),
+                           (0.125, 0.15, 0.15),
+                           (0.250, 0.30, 0.30),
+                           (0.375, 0.60, 0.60),
+                           (0.500, 1.00, 1.00),
+                           (0.625, 0.90, 0.90),
+                           (0.750, 0.90, 0.90),
+                           (0.875, 0.90, 0.90),
+                           (1.000, 1.00, 1.00)),
+                'green':  ((0.000, 0.00, 0.00),
+                           (0.125, 0.15, 0.15),
+                           (0.250, 0.15, 0.15),
+                           (0.375, 0.20, 0.20),
+                           (0.500, 0.25, 0.25),
+                           (0.625, 0.50, 0.50),
+                           (0.750, 0.75, 0.75),
+                           (0.875, 0.90, 0.90),
+                           (1.000, 1.00, 1.00)),
+                'blue':   ((0.000, 0.00, 0.00),
+                           (0.125, 0.50, 0.50),
+                           (0.250, 0.75, 0.75),
+                           (0.375, 0.50, 0.50),
+                           (0.500, 0.15, 0.15),
+                           (0.625, 0.00, 0.00),
+                           (0.750, 0.10, 0.10),
+                           (0.875, 0.50, 0.50),
+                           (1.000, 1.00, 1.00))}
+
+
+# An MIT licensed, colorblind-friendly heatmap from Wistia:
+#   https://github.com/wistia/heatmap-palette
+#   https://wistia.com/learn/culture/heatmaps-for-colorblindness
+#
+# >>> import matplotlib.colors as c
+# >>> colors = ["#e4ff7a", "#ffe81a", "#ffbd00", "#ffa000", "#fc7f00"]
+# >>> cm = c.LinearSegmentedColormap.from_list('wistia', colors)
+# >>> _wistia_data = cm._segmentdata
+# >>> del _wistia_data['alpha']
+#
+_wistia_data = {
+    'red': [(0.0, 0.8941176470588236, 0.8941176470588236),
+            (0.25, 1.0, 1.0),
+            (0.5, 1.0, 1.0),
+            (0.75, 1.0, 1.0),
+            (1.0, 0.9882352941176471, 0.9882352941176471)],
+    'green': [(0.0, 1.0, 1.0),
+              (0.25, 0.9098039215686274, 0.9098039215686274),
+              (0.5, 0.7411764705882353, 0.7411764705882353),
+              (0.75, 0.6274509803921569, 0.6274509803921569),
+              (1.0, 0.4980392156862745, 0.4980392156862745)],
+    'blue': [(0.0, 0.47843137254901963, 0.47843137254901963),
+             (0.25, 0.10196078431372549, 0.10196078431372549),
+             (0.5, 0.0, 0.0),
+             (0.75, 0.0, 0.0),
+             (1.0, 0.0, 0.0)],
+}
+
+
+# Categorical palettes from Vega:
+# https://github.com/vega/vega/wiki/Scales
+# (divided by 255)
+#
+
+_tab10_data = (
+    (0.12156862745098039, 0.4666666666666667,  0.7058823529411765  ),  # 1f77b4
+    (1.0,                 0.4980392156862745,  0.054901960784313725),  # ff7f0e
+    (0.17254901960784313, 0.6274509803921569,  0.17254901960784313 ),  # 2ca02c
+    (0.8392156862745098,  0.15294117647058825, 0.1568627450980392  ),  # d62728
+    (0.5803921568627451,  0.403921568627451,   0.7411764705882353  ),  # 9467bd
+    (0.5490196078431373,  0.33725490196078434, 0.29411764705882354 ),  # 8c564b
+    (0.8901960784313725,  0.4666666666666667,  0.7607843137254902  ),  # e377c2
+    (0.4980392156862745,  0.4980392156862745,  0.4980392156862745  ),  # 7f7f7f
+    (0.7372549019607844,  0.7411764705882353,  0.13333333333333333 ),  # bcbd22
+    (0.09019607843137255, 0.7450980392156863,  0.8117647058823529),    # 17becf
+)
+
+_tab20_data = (
+    (0.12156862745098039, 0.4666666666666667,  0.7058823529411765  ),  # 1f77b4
+    (0.6823529411764706,  0.7803921568627451,  0.9098039215686274  ),  # aec7e8
+    (1.0,                 0.4980392156862745,  0.054901960784313725),  # ff7f0e
+    (1.0,                 0.7333333333333333,  0.47058823529411764 ),  # ffbb78
+    (0.17254901960784313, 0.6274509803921569,  0.17254901960784313 ),  # 2ca02c
+    (0.596078431372549,   0.8745098039215686,  0.5411764705882353  ),  # 98df8a
+    (0.8392156862745098,  0.15294117647058825, 0.1568627450980392  ),  # d62728
+    (1.0,                 0.596078431372549,   0.5882352941176471  ),  # ff9896
+    (0.5803921568627451,  0.403921568627451,   0.7411764705882353  ),  # 9467bd
+    (0.7725490196078432,  0.6901960784313725,  0.8352941176470589  ),  # c5b0d5
+    (0.5490196078431373,  0.33725490196078434, 0.29411764705882354 ),  # 8c564b
+    (0.7686274509803922,  0.611764705882353,   0.5803921568627451  ),  # c49c94
+    (0.8901960784313725,  0.4666666666666667,  0.7607843137254902  ),  # e377c2
+    (0.9686274509803922,  0.7137254901960784,  0.8235294117647058  ),  # f7b6d2
+    (0.4980392156862745,  0.4980392156862745,  0.4980392156862745  ),  # 7f7f7f
+    (0.7803921568627451,  0.7803921568627451,  0.7803921568627451  ),  # c7c7c7
+    (0.7372549019607844,  0.7411764705882353,  0.13333333333333333 ),  # bcbd22
+    (0.8588235294117647,  0.8588235294117647,  0.5529411764705883  ),  # dbdb8d
+    (0.09019607843137255, 0.7450980392156863,  0.8117647058823529  ),  # 17becf
+    (0.6196078431372549,  0.8549019607843137,  0.8980392156862745),    # 9edae5
+)
+
+_tab20b_data = (
+    (0.2235294117647059,  0.23137254901960785, 0.4745098039215686 ),  # 393b79
+    (0.3215686274509804,  0.32941176470588235, 0.6392156862745098 ),  # 5254a3
+    (0.4196078431372549,  0.43137254901960786, 0.8117647058823529 ),  # 6b6ecf
+    (0.611764705882353,   0.6196078431372549,  0.8705882352941177 ),  # 9c9ede
+    (0.38823529411764707, 0.4745098039215686,  0.2235294117647059 ),  # 637939
+    (0.5490196078431373,  0.6352941176470588,  0.3215686274509804 ),  # 8ca252
+    (0.7098039215686275,  0.8117647058823529,  0.4196078431372549 ),  # b5cf6b
+    (0.807843137254902,   0.8588235294117647,  0.611764705882353  ),  # cedb9c
+    (0.5490196078431373,  0.42745098039215684, 0.19215686274509805),  # 8c6d31
+    (0.7411764705882353,  0.6196078431372549,  0.2235294117647059 ),  # bd9e39
+    (0.9058823529411765,  0.7294117647058823,  0.3215686274509804 ),  # e7ba52
+    (0.9058823529411765,  0.796078431372549,   0.5803921568627451 ),  # e7cb94
+    (0.5176470588235295,  0.23529411764705882, 0.2235294117647059 ),  # 843c39
+    (0.6784313725490196,  0.28627450980392155, 0.2901960784313726 ),  # ad494a
+    (0.8392156862745098,  0.3803921568627451,  0.4196078431372549 ),  # d6616b
+    (0.9058823529411765,  0.5882352941176471,  0.611764705882353  ),  # e7969c
+    (0.4823529411764706,  0.2549019607843137,  0.45098039215686275),  # 7b4173
+    (0.6470588235294118,  0.3176470588235294,  0.5803921568627451 ),  # a55194
+    (0.807843137254902,   0.42745098039215684, 0.7411764705882353 ),  # ce6dbd
+    (0.8705882352941177,  0.6196078431372549,  0.8392156862745098 ),  # de9ed6
+)
+
+_tab20c_data = (
+    (0.19215686274509805, 0.5098039215686274,  0.7411764705882353  ),  # 3182bd
+    (0.4196078431372549,  0.6823529411764706,  0.8392156862745098  ),  # 6baed6
+    (0.6196078431372549,  0.792156862745098,   0.8823529411764706  ),  # 9ecae1
+    (0.7764705882352941,  0.8588235294117647,  0.9372549019607843  ),  # c6dbef
+    (0.9019607843137255,  0.3333333333333333,  0.050980392156862744),  # e6550d
+    (0.9921568627450981,  0.5529411764705883,  0.23529411764705882 ),  # fd8d3c
+    (0.9921568627450981,  0.6823529411764706,  0.4196078431372549  ),  # fdae6b
+    (0.9921568627450981,  0.8156862745098039,  0.6352941176470588  ),  # fdd0a2
+    (0.19215686274509805, 0.6392156862745098,  0.32941176470588235 ),  # 31a354
+    (0.4549019607843137,  0.7686274509803922,  0.4627450980392157  ),  # 74c476
+    (0.6313725490196078,  0.8509803921568627,  0.6078431372549019  ),  # a1d99b
+    (0.7803921568627451,  0.9137254901960784,  0.7529411764705882  ),  # c7e9c0
+    (0.4588235294117647,  0.4196078431372549,  0.6941176470588235  ),  # 756bb1
+    (0.6196078431372549,  0.6039215686274509,  0.7843137254901961  ),  # 9e9ac8
+    (0.7372549019607844,  0.7411764705882353,  0.8627450980392157  ),  # bcbddc
+    (0.8549019607843137,  0.8549019607843137,  0.9215686274509803  ),  # dadaeb
+    (0.38823529411764707, 0.38823529411764707, 0.38823529411764707 ),  # 636363
+    (0.5882352941176471,  0.5882352941176471,  0.5882352941176471  ),  # 969696
+    (0.7411764705882353,  0.7411764705882353,  0.7411764705882353  ),  # bdbdbd
+    (0.8509803921568627,  0.8509803921568627,  0.8509803921568627  ),  # d9d9d9
+)
+
+
+datad = {
+    'Blues': _Blues_data,
+    'BrBG': _BrBG_data,
+    'BuGn': _BuGn_data,
+    'BuPu': _BuPu_data,
+    'CMRmap': _CMRmap_data,
+    'GnBu': _GnBu_data,
+    'Greens': _Greens_data,
+    'Greys': _Greys_data,
+    'OrRd': _OrRd_data,
+    'Oranges': _Oranges_data,
+    'PRGn': _PRGn_data,
+    'PiYG': _PiYG_data,
+    'PuBu': _PuBu_data,
+    'PuBuGn': _PuBuGn_data,
+    'PuOr': _PuOr_data,
+    'PuRd': _PuRd_data,
+    'Purples': _Purples_data,
+    'RdBu': _RdBu_data,
+    'RdGy': _RdGy_data,
+    'RdPu': _RdPu_data,
+    'RdYlBu': _RdYlBu_data,
+    'RdYlGn': _RdYlGn_data,
+    'Reds': _Reds_data,
+    'Spectral': _Spectral_data,
+    'Wistia': _wistia_data,
+    'YlGn': _YlGn_data,
+    'YlGnBu': _YlGnBu_data,
+    'YlOrBr': _YlOrBr_data,
+    'YlOrRd': _YlOrRd_data,
+    'afmhot': _afmhot_data,
+    'autumn': _autumn_data,
+    'binary': _binary_data,
+    'bone': _bone_data,
+    'brg': _brg_data,
+    'bwr': _bwr_data,
+    'cool': _cool_data,
+    'coolwarm': _coolwarm_data,
+    'copper': _copper_data,
+    'cubehelix': _cubehelix_data,
+    'flag': _flag_data,
+    'gist_earth': _gist_earth_data,
+    'gist_gray': _gist_gray_data,
+    'gist_heat': _gist_heat_data,
+    'gist_ncar': _gist_ncar_data,
+    'gist_rainbow': _gist_rainbow_data,
+    'gist_stern': _gist_stern_data,
+    'gist_yarg': _gist_yarg_data,
+    'gnuplot': _gnuplot_data,
+    'gnuplot2': _gnuplot2_data,
+    'gray': _gray_data,
+    'hot': _hot_data,
+    'hsv': _hsv_data,
+    'jet': _jet_data,
+    'nipy_spectral': _nipy_spectral_data,
+    'ocean': _ocean_data,
+    'pink': _pink_data,
+    'prism': _prism_data,
+    'rainbow': _rainbow_data,
+    'seismic': _seismic_data,
+    'spring': _spring_data,
+    'summer': _summer_data,
+    'terrain': _terrain_data,
+    'winter': _winter_data,
+    # Qualitative
+    'Accent': {'listed': _Accent_data},
+    'Dark2': {'listed': _Dark2_data},
+    'Paired': {'listed': _Paired_data},
+    'Pastel1': {'listed': _Pastel1_data},
+    'Pastel2': {'listed': _Pastel2_data},
+    'Set1': {'listed': _Set1_data},
+    'Set2': {'listed': _Set2_data},
+    'Set3': {'listed': _Set3_data},
+    'tab10': {'listed': _tab10_data},
+    'tab20': {'listed': _tab20_data},
+    'tab20b': {'listed': _tab20b_data},
+    'tab20c': {'listed': _tab20c_data},
+}

llava_next/lib/python3.10/site-packages/matplotlib/_color_data.py

@@ -0,0 +1,1141 @@
+BASE_COLORS = {
+    'b': (0, 0, 1),        # blue
+    'g': (0, 0.5, 0),      # green
+    'r': (1, 0, 0),        # red
+    'c': (0, 0.75, 0.75),  # cyan
+    'm': (0.75, 0, 0.75),  # magenta
+    'y': (0.75, 0.75, 0),  # yellow
+    'k': (0, 0, 0),        # black
+    'w': (1, 1, 1),        # white
+}
+
+
+# These colors are from Tableau
+TABLEAU_COLORS = {
+    'tab:blue': '#1f77b4',
+    'tab:orange': '#ff7f0e',
+    'tab:green': '#2ca02c',
+    'tab:red': '#d62728',
+    'tab:purple': '#9467bd',
+    'tab:brown': '#8c564b',
+    'tab:pink': '#e377c2',
+    'tab:gray': '#7f7f7f',
+    'tab:olive': '#bcbd22',
+    'tab:cyan': '#17becf',
+}
+
+
+# This mapping of color names -> hex values is taken from
+# a survey run by Randall Munroe see:
+# https://blog.xkcd.com/2010/05/03/color-survey-results/
+# for more details.  The results are hosted at
+# https://xkcd.com/color/rgb/
+# and also available as a text file at
+# https://xkcd.com/color/rgb.txt
+#
+# License: https://creativecommons.org/publicdomain/zero/1.0/
+XKCD_COLORS = {
+    'cloudy blue': '#acc2d9',
+    'dark pastel green': '#56ae57',
+    'dust': '#b2996e',
+    'electric lime': '#a8ff04',
+    'fresh green': '#69d84f',
+    'light eggplant': '#894585',
+    'nasty green': '#70b23f',
+    'really light blue': '#d4ffff',
+    'tea': '#65ab7c',
+    'warm purple': '#952e8f',
+    'yellowish tan': '#fcfc81',
+    'cement': '#a5a391',
+    'dark grass green': '#388004',
+    'dusty teal': '#4c9085',
+    'grey teal': '#5e9b8a',
+    'macaroni and cheese': '#efb435',
+    'pinkish tan': '#d99b82',
+    'spruce': '#0a5f38',
+    'strong blue': '#0c06f7',
+    'toxic green': '#61de2a',
+    'windows blue': '#3778bf',
+    'blue blue': '#2242c7',
+    'blue with a hint of purple': '#533cc6',
+    'booger': '#9bb53c',
+    'bright sea green': '#05ffa6',
+    'dark green blue': '#1f6357',
+    'deep turquoise': '#017374',
+    'green teal': '#0cb577',
+    'strong pink': '#ff0789',
+    'bland': '#afa88b',
+    'deep aqua': '#08787f',
+    'lavender pink': '#dd85d7',
+    'light moss green': '#a6c875',
+    'light seafoam green': '#a7ffb5',
+    'olive yellow': '#c2b709',
+    'pig pink': '#e78ea5',
+    'deep lilac': '#966ebd',
+    'desert': '#ccad60',
+    'dusty lavender': '#ac86a8',
+    'purpley grey': '#947e94',
+    'purply': '#983fb2',
+    'candy pink': '#ff63e9',
+    'light pastel green': '#b2fba5',
+    'boring green': '#63b365',
+    'kiwi green': '#8ee53f',
+    'light grey green': '#b7e1a1',
+    'orange pink': '#ff6f52',
+    'tea green': '#bdf8a3',
+    'very light brown': '#d3b683',
+    'egg shell': '#fffcc4',
+    'eggplant purple': '#430541',
+    'powder pink': '#ffb2d0',
+    'reddish grey': '#997570',
+    'baby shit brown': '#ad900d',
+    'liliac': '#c48efd',
+    'stormy blue': '#507b9c',
+    'ugly brown': '#7d7103',
+    'custard': '#fffd78',
+    'darkish pink': '#da467d',
+    'deep brown': '#410200',
+    'greenish beige': '#c9d179',
+    'manilla': '#fffa86',
+    'off blue': '#5684ae',
+    'battleship grey': '#6b7c85',
+    'browny green': '#6f6c0a',
+    'bruise': '#7e4071',
+    'kelley green': '#009337',
+    'sickly yellow': '#d0e429',
+    'sunny yellow': '#fff917',
+    'azul': '#1d5dec',
+    'darkgreen': '#054907',
+    'green/yellow': '#b5ce08',
+    'lichen': '#8fb67b',
+    'light light green': '#c8ffb0',
+    'pale gold': '#fdde6c',
+    'sun yellow': '#ffdf22',
+    'tan green': '#a9be70',
+    'burple': '#6832e3',
+    'butterscotch': '#fdb147',
+    'toupe': '#c7ac7d',
+    'dark cream': '#fff39a',
+    'indian red': '#850e04',
+    'light lavendar': '#efc0fe',
+    'poison green': '#40fd14',
+    'baby puke green': '#b6c406',
+    'bright yellow green': '#9dff00',
+    'charcoal grey': '#3c4142',
+    'squash': '#f2ab15',
+    'cinnamon': '#ac4f06',
+    'light pea green': '#c4fe82',
+    'radioactive green': '#2cfa1f',
+    'raw sienna': '#9a6200',
+    'baby purple': '#ca9bf7',
+    'cocoa': '#875f42',
+    'light royal blue': '#3a2efe',
+    'orangeish': '#fd8d49',
+    'rust brown': '#8b3103',
+    'sand brown': '#cba560',
+    'swamp': '#698339',
+    'tealish green': '#0cdc73',
+    'burnt siena': '#b75203',
+    'camo': '#7f8f4e',
+    'dusk blue': '#26538d',
+    'fern': '#63a950',
+    'old rose': '#c87f89',
+    'pale light green': '#b1fc99',
+    'peachy pink': '#ff9a8a',
+    'rosy pink': '#f6688e',
+    'light bluish green': '#76fda8',
+    'light bright green': '#53fe5c',
+    'light neon green': '#4efd54',
+    'light seafoam': '#a0febf',
+    'tiffany blue': '#7bf2da',
+    'washed out green': '#bcf5a6',
+    'browny orange': '#ca6b02',
+    'nice blue': '#107ab0',
+    'sapphire': '#2138ab',
+    'greyish teal': '#719f91',
+    'orangey yellow': '#fdb915',
+    'parchment': '#fefcaf',
+    'straw': '#fcf679',
+    'very dark brown': '#1d0200',
+    'terracota': '#cb6843',
+    'ugly blue': '#31668a',
+    'clear blue': '#247afd',
+    'creme': '#ffffb6',
+    'foam green': '#90fda9',
+    'grey/green': '#86a17d',
+    'light gold': '#fddc5c',
+    'seafoam blue': '#78d1b6',
+    'topaz': '#13bbaf',
+    'violet pink': '#fb5ffc',
+    'wintergreen': '#20f986',
+    'yellow tan': '#ffe36e',
+    'dark fuchsia': '#9d0759',
+    'indigo blue': '#3a18b1',
+    'light yellowish green': '#c2ff89',
+    'pale magenta': '#d767ad',
+    'rich purple': '#720058',
+    'sunflower yellow': '#ffda03',
+    'green/blue': '#01c08d',
+    'leather': '#ac7434',
+    'racing green': '#014600',
+    'vivid purple': '#9900fa',
+    'dark royal blue': '#02066f',
+    'hazel': '#8e7618',
+    'muted pink': '#d1768f',
+    'booger green': '#96b403',
+    'canary': '#fdff63',
+    'cool grey': '#95a3a6',
+    'dark taupe': '#7f684e',
+    'darkish purple': '#751973',
+    'true green': '#089404',
+    'coral pink': '#ff6163',
+    'dark sage': '#598556',
+    'dark slate blue': '#214761',
+    'flat blue': '#3c73a8',
+    'mushroom': '#ba9e88',
+    'rich blue': '#021bf9',
+    'dirty purple': '#734a65',
+    'greenblue': '#23c48b',
+    'icky green': '#8fae22',
+    'light khaki': '#e6f2a2',
+    'warm blue': '#4b57db',
+    'dark hot pink': '#d90166',
+    'deep sea blue': '#015482',
+    'carmine': '#9d0216',
+    'dark yellow green': '#728f02',
+    'pale peach': '#ffe5ad',
+    'plum purple': '#4e0550',
+    'golden rod': '#f9bc08',
+    'neon red': '#ff073a',
+    'old pink': '#c77986',
+    'very pale blue': '#d6fffe',
+    'blood orange': '#fe4b03',
+    'grapefruit': '#fd5956',
+    'sand yellow': '#fce166',
+    'clay brown': '#b2713d',
+    'dark blue grey': '#1f3b4d',
+    'flat green': '#699d4c',
+    'light green blue': '#56fca2',
+    'warm pink': '#fb5581',
+    'dodger blue': '#3e82fc',
+    'gross green': '#a0bf16',
+    'ice': '#d6fffa',
+    'metallic blue': '#4f738e',
+    'pale salmon': '#ffb19a',
+    'sap green': '#5c8b15',
+    'algae': '#54ac68',
+    'bluey grey': '#89a0b0',
+    'greeny grey': '#7ea07a',
+    'highlighter green': '#1bfc06',
+    'light light blue': '#cafffb',
+    'light mint': '#b6ffbb',
+    'raw umber': '#a75e09',
+    'vivid blue': '#152eff',
+    'deep lavender': '#8d5eb7',
+    'dull teal': '#5f9e8f',
+    'light greenish blue': '#63f7b4',
+    'mud green': '#606602',
+    'pinky': '#fc86aa',
+    'red wine': '#8c0034',
+    'shit green': '#758000',
+    'tan brown': '#ab7e4c',
+    'darkblue': '#030764',
+    'rosa': '#fe86a4',
+    'lipstick': '#d5174e',
+    'pale mauve': '#fed0fc',
+    'claret': '#680018',
+    'dandelion': '#fedf08',
+    'orangered': '#fe420f',
+    'poop green': '#6f7c00',
+    'ruby': '#ca0147',
+    'dark': '#1b2431',
+    'greenish turquoise': '#00fbb0',
+    'pastel red': '#db5856',
+    'piss yellow': '#ddd618',
+    'bright cyan': '#41fdfe',
+    'dark coral': '#cf524e',
+    'algae green': '#21c36f',
+    'darkish red': '#a90308',
+    'reddy brown': '#6e1005',
+    'blush pink': '#fe828c',
+    'camouflage green': '#4b6113',
+    'lawn green': '#4da409',
+    'putty': '#beae8a',
+    'vibrant blue': '#0339f8',
+    'dark sand': '#a88f59',
+    'purple/blue': '#5d21d0',
+    'saffron': '#feb209',
+    'twilight': '#4e518b',
+    'warm brown': '#964e02',
+    'bluegrey': '#85a3b2',
+    'bubble gum pink': '#ff69af',
+    'duck egg blue': '#c3fbf4',
+    'greenish cyan': '#2afeb7',
+    'petrol': '#005f6a',
+    'royal': '#0c1793',
+    'butter': '#ffff81',
+    'dusty orange': '#f0833a',
+    'off yellow': '#f1f33f',
+    'pale olive green': '#b1d27b',
+    'orangish': '#fc824a',
+    'leaf': '#71aa34',
+    'light blue grey': '#b7c9e2',
+    'dried blood': '#4b0101',
+    'lightish purple': '#a552e6',
+    'rusty red': '#af2f0d',
+    'lavender blue': '#8b88f8',
+    'light grass green': '#9af764',
+    'light mint green': '#a6fbb2',
+    'sunflower': '#ffc512',
+    'velvet': '#750851',
+    'brick orange': '#c14a09',
+    'lightish red': '#fe2f4a',
+    'pure blue': '#0203e2',
+    'twilight blue': '#0a437a',
+    'violet red': '#a50055',
+    'yellowy brown': '#ae8b0c',
+    'carnation': '#fd798f',
+    'muddy yellow': '#bfac05',
+    'dark seafoam green': '#3eaf76',
+    'deep rose': '#c74767',
+    'dusty red': '#b9484e',
+    'grey/blue': '#647d8e',
+    'lemon lime': '#bffe28',
+    'purple/pink': '#d725de',
+    'brown yellow': '#b29705',
+    'purple brown': '#673a3f',
+    'wisteria': '#a87dc2',
+    'banana yellow': '#fafe4b',
+    'lipstick red': '#c0022f',
+    'water blue': '#0e87cc',
+    'brown grey': '#8d8468',
+    'vibrant purple': '#ad03de',
+    'baby green': '#8cff9e',
+    'barf green': '#94ac02',
+    'eggshell blue': '#c4fff7',
+    'sandy yellow': '#fdee73',
+    'cool green': '#33b864',
+    'pale': '#fff9d0',
+    'blue/grey': '#758da3',
+    'hot magenta': '#f504c9',
+    'greyblue': '#77a1b5',
+    'purpley': '#8756e4',
+    'baby shit green': '#889717',
+    'brownish pink': '#c27e79',
+    'dark aquamarine': '#017371',
+    'diarrhea': '#9f8303',
+    'light mustard': '#f7d560',
+    'pale sky blue': '#bdf6fe',
+    'turtle green': '#75b84f',
+    'bright olive': '#9cbb04',
+    'dark grey blue': '#29465b',
+    'greeny brown': '#696006',
+    'lemon green': '#adf802',
+    'light periwinkle': '#c1c6fc',
+    'seaweed green': '#35ad6b',
+    'sunshine yellow': '#fffd37',
+    'ugly purple': '#a442a0',
+    'medium pink': '#f36196',
+    'puke brown': '#947706',
+    'very light pink': '#fff4f2',
+    'viridian': '#1e9167',
+    'bile': '#b5c306',
+    'faded yellow': '#feff7f',
+    'very pale green': '#cffdbc',
+    'vibrant green': '#0add08',
+    'bright lime': '#87fd05',
+    'spearmint': '#1ef876',
+    'light aquamarine': '#7bfdc7',
+    'light sage': '#bcecac',
+    'yellowgreen': '#bbf90f',
+    'baby poo': '#ab9004',
+    'dark seafoam': '#1fb57a',
+    'deep teal': '#00555a',
+    'heather': '#a484ac',
+    'rust orange': '#c45508',
+    'dirty blue': '#3f829d',
+    'fern green': '#548d44',
+    'bright lilac': '#c95efb',
+    'weird green': '#3ae57f',
+    'peacock blue': '#016795',
+    'avocado green': '#87a922',
+    'faded orange': '#f0944d',
+    'grape purple': '#5d1451',
+    'hot green': '#25ff29',
+    'lime yellow': '#d0fe1d',
+    'mango': '#ffa62b',
+    'shamrock': '#01b44c',
+    'bubblegum': '#ff6cb5',
+    'purplish brown': '#6b4247',
+    'vomit yellow': '#c7c10c',
+    'pale cyan': '#b7fffa',
+    'key lime': '#aeff6e',
+    'tomato red': '#ec2d01',
+    'lightgreen': '#76ff7b',
+    'merlot': '#730039',
+    'night blue': '#040348',
+    'purpleish pink': '#df4ec8',
+    'apple': '#6ecb3c',
+    'baby poop green': '#8f9805',
+    'green apple': '#5edc1f',
+    'heliotrope': '#d94ff5',
+    'yellow/green': '#c8fd3d',
+    'almost black': '#070d0d',
+    'cool blue': '#4984b8',
+    'leafy green': '#51b73b',
+    'mustard brown': '#ac7e04',
+    'dusk': '#4e5481',
+    'dull brown': '#876e4b',
+    'frog green': '#58bc08',
+    'vivid green': '#2fef10',
+    'bright light green': '#2dfe54',
+    'fluro green': '#0aff02',
+    'kiwi': '#9cef43',
+    'seaweed': '#18d17b',
+    'navy green': '#35530a',
+    'ultramarine blue': '#1805db',
+    'iris': '#6258c4',
+    'pastel orange': '#ff964f',
+    'yellowish orange': '#ffab0f',
+    'perrywinkle': '#8f8ce7',
+    'tealish': '#24bca8',
+    'dark plum': '#3f012c',
+    'pear': '#cbf85f',
+    'pinkish orange': '#ff724c',
+    'midnight purple': '#280137',
+    'light urple': '#b36ff6',
+    'dark mint': '#48c072',
+    'greenish tan': '#bccb7a',
+    'light burgundy': '#a8415b',
+    'turquoise blue': '#06b1c4',
+    'ugly pink': '#cd7584',
+    'sandy': '#f1da7a',
+    'electric pink': '#ff0490',
+    'muted purple': '#805b87',
+    'mid green': '#50a747',
+    'greyish': '#a8a495',
+    'neon yellow': '#cfff04',
+    'banana': '#ffff7e',
+    'carnation pink': '#ff7fa7',
+    'tomato': '#ef4026',
+    'sea': '#3c9992',
+    'muddy brown': '#886806',
+    'turquoise green': '#04f489',
+    'buff': '#fef69e',
+    'fawn': '#cfaf7b',
+    'muted blue': '#3b719f',
+    'pale rose': '#fdc1c5',
+    'dark mint green': '#20c073',
+    'amethyst': '#9b5fc0',
+    'blue/green': '#0f9b8e',
+    'chestnut': '#742802',
+    'sick green': '#9db92c',
+    'pea': '#a4bf20',
+    'rusty orange': '#cd5909',
+    'stone': '#ada587',
+    'rose red': '#be013c',
+    'pale aqua': '#b8ffeb',
+    'deep orange': '#dc4d01',
+    'earth': '#a2653e',
+    'mossy green': '#638b27',
+    'grassy green': '#419c03',
+    'pale lime green': '#b1ff65',
+    'light grey blue': '#9dbcd4',
+    'pale grey': '#fdfdfe',
+    'asparagus': '#77ab56',
+    'blueberry': '#464196',
+    'purple red': '#990147',
+    'pale lime': '#befd73',
+    'greenish teal': '#32bf84',
+    'caramel': '#af6f09',
+    'deep magenta': '#a0025c',
+    'light peach': '#ffd8b1',
+    'milk chocolate': '#7f4e1e',
+    'ocher': '#bf9b0c',
+    'off green': '#6ba353',
+    'purply pink': '#f075e6',
+    'lightblue': '#7bc8f6',
+    'dusky blue': '#475f94',
+    'golden': '#f5bf03',
+    'light beige': '#fffeb6',
+    'butter yellow': '#fffd74',
+    'dusky purple': '#895b7b',
+    'french blue': '#436bad',
+    'ugly yellow': '#d0c101',
+    'greeny yellow': '#c6f808',
+    'orangish red': '#f43605',
+    'shamrock green': '#02c14d',
+    'orangish brown': '#b25f03',
+    'tree green': '#2a7e19',
+    'deep violet': '#490648',
+    'gunmetal': '#536267',
+    'blue/purple': '#5a06ef',
+    'cherry': '#cf0234',
+    'sandy brown': '#c4a661',
+    'warm grey': '#978a84',
+    'dark indigo': '#1f0954',
+    'midnight': '#03012d',
+    'bluey green': '#2bb179',
+    'grey pink': '#c3909b',
+    'soft purple': '#a66fb5',
+    'blood': '#770001',
+    'brown red': '#922b05',
+    'medium grey': '#7d7f7c',
+    'berry': '#990f4b',
+    'poo': '#8f7303',
+    'purpley pink': '#c83cb9',
+    'light salmon': '#fea993',
+    'snot': '#acbb0d',
+    'easter purple': '#c071fe',
+    'light yellow green': '#ccfd7f',
+    'dark navy blue': '#00022e',
+    'drab': '#828344',
+    'light rose': '#ffc5cb',
+    'rouge': '#ab1239',
+    'purplish red': '#b0054b',
+    'slime green': '#99cc04',
+    'baby poop': '#937c00',
+    'irish green': '#019529',
+    'pink/purple': '#ef1de7',
+    'dark navy': '#000435',
+    'greeny blue': '#42b395',
+    'light plum': '#9d5783',
+    'pinkish grey': '#c8aca9',
+    'dirty orange': '#c87606',
+    'rust red': '#aa2704',
+    'pale lilac': '#e4cbff',
+    'orangey red': '#fa4224',
+    'primary blue': '#0804f9',
+    'kermit green': '#5cb200',
+    'brownish purple': '#76424e',
+    'murky green': '#6c7a0e',
+    'wheat': '#fbdd7e',
+    'very dark purple': '#2a0134',
+    'bottle green': '#044a05',
+    'watermelon': '#fd4659',
+    'deep sky blue': '#0d75f8',
+    'fire engine red': '#fe0002',
+    'yellow ochre': '#cb9d06',
+    'pumpkin orange': '#fb7d07',
+    'pale olive': '#b9cc81',
+    'light lilac': '#edc8ff',
+    'lightish green': '#61e160',
+    'carolina blue': '#8ab8fe',
+    'mulberry': '#920a4e',
+    'shocking pink': '#fe02a2',
+    'auburn': '#9a3001',
+    'bright lime green': '#65fe08',
+    'celadon': '#befdb7',
+    'pinkish brown': '#b17261',
+    'poo brown': '#885f01',
+    'bright sky blue': '#02ccfe',
+    'celery': '#c1fd95',
+    'dirt brown': '#836539',
+    'strawberry': '#fb2943',
+    'dark lime': '#84b701',
+    'copper': '#b66325',
+    'medium brown': '#7f5112',
+    'muted green': '#5fa052',
+    "robin's egg": '#6dedfd',
+    'bright aqua': '#0bf9ea',
+    'bright lavender': '#c760ff',
+    'ivory': '#ffffcb',
+    'very light purple': '#f6cefc',
+    'light navy': '#155084',
+    'pink red': '#f5054f',
+    'olive brown': '#645403',
+    'poop brown': '#7a5901',
+    'mustard green': '#a8b504',
+    'ocean green': '#3d9973',
+    'very dark blue': '#000133',
+    'dusty green': '#76a973',
+    'light navy blue': '#2e5a88',
+    'minty green': '#0bf77d',
+    'adobe': '#bd6c48',
+    'barney': '#ac1db8',
+    'jade green': '#2baf6a',
+    'bright light blue': '#26f7fd',
+    'light lime': '#aefd6c',
+    'dark khaki': '#9b8f55',
+    'orange yellow': '#ffad01',
+    'ocre': '#c69c04',
+    'maize': '#f4d054',
+    'faded pink': '#de9dac',
+    'british racing green': '#05480d',
+    'sandstone': '#c9ae74',
+    'mud brown': '#60460f',
+    'light sea green': '#98f6b0',
+    'robin egg blue': '#8af1fe',
+    'aqua marine': '#2ee8bb',
+    'dark sea green': '#11875d',
+    'soft pink': '#fdb0c0',
+    'orangey brown': '#b16002',
+    'cherry red': '#f7022a',
+    'burnt yellow': '#d5ab09',
+    'brownish grey': '#86775f',
+    'camel': '#c69f59',
+    'purplish grey': '#7a687f',
+    'marine': '#042e60',
+    'greyish pink': '#c88d94',
+    'pale turquoise': '#a5fbd5',
+    'pastel yellow': '#fffe71',
+    'bluey purple': '#6241c7',
+    'canary yellow': '#fffe40',
+    'faded red': '#d3494e',
+    'sepia': '#985e2b',
+    'coffee': '#a6814c',
+    'bright magenta': '#ff08e8',
+    'mocha': '#9d7651',
+    'ecru': '#feffca',
+    'purpleish': '#98568d',
+    'cranberry': '#9e003a',
+    'darkish green': '#287c37',
+    'brown orange': '#b96902',
+    'dusky rose': '#ba6873',
+    'melon': '#ff7855',
+    'sickly green': '#94b21c',
+    'silver': '#c5c9c7',
+    'purply blue': '#661aee',
+    'purpleish blue': '#6140ef',
+    'hospital green': '#9be5aa',
+    'shit brown': '#7b5804',
+    'mid blue': '#276ab3',
+    'amber': '#feb308',
+    'easter green': '#8cfd7e',
+    'soft blue': '#6488ea',
+    'cerulean blue': '#056eee',
+    'golden brown': '#b27a01',
+    'bright turquoise': '#0ffef9',
+    'red pink': '#fa2a55',
+    'red purple': '#820747',
+    'greyish brown': '#7a6a4f',
+    'vermillion': '#f4320c',
+    'russet': '#a13905',
+    'steel grey': '#6f828a',
+    'lighter purple': '#a55af4',
+    'bright violet': '#ad0afd',
+    'prussian blue': '#004577',
+    'slate green': '#658d6d',
+    'dirty pink': '#ca7b80',
+    'dark blue green': '#005249',
+    'pine': '#2b5d34',
+    'yellowy green': '#bff128',
+    'dark gold': '#b59410',
+    'bluish': '#2976bb',
+    'darkish blue': '#014182',
+    'dull red': '#bb3f3f',
+    'pinky red': '#fc2647',
+    'bronze': '#a87900',
+    'pale teal': '#82cbb2',
+    'military green': '#667c3e',
+    'barbie pink': '#fe46a5',
+    'bubblegum pink': '#fe83cc',
+    'pea soup green': '#94a617',
+    'dark mustard': '#a88905',
+    'shit': '#7f5f00',
+    'medium purple': '#9e43a2',
+    'very dark green': '#062e03',
+    'dirt': '#8a6e45',
+    'dusky pink': '#cc7a8b',
+    'red violet': '#9e0168',
+    'lemon yellow': '#fdff38',
+    'pistachio': '#c0fa8b',
+    'dull yellow': '#eedc5b',
+    'dark lime green': '#7ebd01',
+    'denim blue': '#3b5b92',
+    'teal blue': '#01889f',
+    'lightish blue': '#3d7afd',
+    'purpley blue': '#5f34e7',
+    'light indigo': '#6d5acf',
+    'swamp green': '#748500',
+    'brown green': '#706c11',
+    'dark maroon': '#3c0008',
+    'hot purple': '#cb00f5',
+    'dark forest green': '#002d04',
+    'faded blue': '#658cbb',
+    'drab green': '#749551',
+    'light lime green': '#b9ff66',
+    'snot green': '#9dc100',
+    'yellowish': '#faee66',
+    'light blue green': '#7efbb3',
+    'bordeaux': '#7b002c',
+    'light mauve': '#c292a1',
+    'ocean': '#017b92',
+    'marigold': '#fcc006',
+    'muddy green': '#657432',
+    'dull orange': '#d8863b',
+    'steel': '#738595',
+    'electric purple': '#aa23ff',
+    'fluorescent green': '#08ff08',
+    'yellowish brown': '#9b7a01',
+    'blush': '#f29e8e',
+    'soft green': '#6fc276',
+    'bright orange': '#ff5b00',
+    'lemon': '#fdff52',
+    'purple grey': '#866f85',
+    'acid green': '#8ffe09',
+    'pale lavender': '#eecffe',
+    'violet blue': '#510ac9',
+    'light forest green': '#4f9153',
+    'burnt red': '#9f2305',
+    'khaki green': '#728639',
+    'cerise': '#de0c62',
+    'faded purple': '#916e99',
+    'apricot': '#ffb16d',
+    'dark olive green': '#3c4d03',
+    'grey brown': '#7f7053',
+    'green grey': '#77926f',
+    'true blue': '#010fcc',
+    'pale violet': '#ceaefa',
+    'periwinkle blue': '#8f99fb',
+    'light sky blue': '#c6fcff',
+    'blurple': '#5539cc',
+    'green brown': '#544e03',
+    'bluegreen': '#017a79',
+    'bright teal': '#01f9c6',
+    'brownish yellow': '#c9b003',
+    'pea soup': '#929901',
+    'forest': '#0b5509',
+    'barney purple': '#a00498',
+    'ultramarine': '#2000b1',
+    'purplish': '#94568c',
+    'puke yellow': '#c2be0e',
+    'bluish grey': '#748b97',
+    'dark periwinkle': '#665fd1',
+    'dark lilac': '#9c6da5',
+    'reddish': '#c44240',
+    'light maroon': '#a24857',
+    'dusty purple': '#825f87',
+    'terra cotta': '#c9643b',
+    'avocado': '#90b134',
+    'marine blue': '#01386a',
+    'teal green': '#25a36f',
+    'slate grey': '#59656d',
+    'lighter green': '#75fd63',
+    'electric green': '#21fc0d',
+    'dusty blue': '#5a86ad',
+    'golden yellow': '#fec615',
+    'bright yellow': '#fffd01',
+    'light lavender': '#dfc5fe',
+    'umber': '#b26400',
+    'poop': '#7f5e00',
+    'dark peach': '#de7e5d',
+    'jungle green': '#048243',
+    'eggshell': '#ffffd4',
+    'denim': '#3b638c',
+    'yellow brown': '#b79400',
+    'dull purple': '#84597e',
+    'chocolate brown': '#411900',
+    'wine red': '#7b0323',
+    'neon blue': '#04d9ff',
+    'dirty green': '#667e2c',
+    'light tan': '#fbeeac',
+    'ice blue': '#d7fffe',
+    'cadet blue': '#4e7496',
+    'dark mauve': '#874c62',
+    'very light blue': '#d5ffff',
+    'grey purple': '#826d8c',
+    'pastel pink': '#ffbacd',
+    'very light green': '#d1ffbd',
+    'dark sky blue': '#448ee4',
+    'evergreen': '#05472a',
+    'dull pink': '#d5869d',
+    'aubergine': '#3d0734',
+    'mahogany': '#4a0100',
+    'reddish orange': '#f8481c',
+    'deep green': '#02590f',
+    'vomit green': '#89a203',
+    'purple pink': '#e03fd8',
+    'dusty pink': '#d58a94',
+    'faded green': '#7bb274',
+    'camo green': '#526525',
+    'pinky purple': '#c94cbe',
+    'pink purple': '#db4bda',
+    'brownish red': '#9e3623',
+    'dark rose': '#b5485d',
+    'mud': '#735c12',
+    'brownish': '#9c6d57',
+    'emerald green': '#028f1e',
+    'pale brown': '#b1916e',
+    'dull blue': '#49759c',
+    'burnt umber': '#a0450e',
+    'medium green': '#39ad48',
+    'clay': '#b66a50',
+    'light aqua': '#8cffdb',
+    'light olive green': '#a4be5c',
+    'brownish orange': '#cb7723',
+    'dark aqua': '#05696b',
+    'purplish pink': '#ce5dae',
+    'dark salmon': '#c85a53',
+    'greenish grey': '#96ae8d',
+    'jade': '#1fa774',
+    'ugly green': '#7a9703',
+    'dark beige': '#ac9362',
+    'emerald': '#01a049',
+    'pale red': '#d9544d',
+    'light magenta': '#fa5ff7',
+    'sky': '#82cafc',
+    'light cyan': '#acfffc',
+    'yellow orange': '#fcb001',
+    'reddish purple': '#910951',
+    'reddish pink': '#fe2c54',
+    'orchid': '#c875c4',
+    'dirty yellow': '#cdc50a',
+    'orange red': '#fd411e',
+    'deep red': '#9a0200',
+    'orange brown': '#be6400',
+    'cobalt blue': '#030aa7',
+    'neon pink': '#fe019a',
+    'rose pink': '#f7879a',
+    'greyish purple': '#887191',
+    'raspberry': '#b00149',
+    'aqua green': '#12e193',
+    'salmon pink': '#fe7b7c',
+    'tangerine': '#ff9408',
+    'brownish green': '#6a6e09',
+    'red brown': '#8b2e16',
+    'greenish brown': '#696112',
+    'pumpkin': '#e17701',
+    'pine green': '#0a481e',
+    'charcoal': '#343837',
+    'baby pink': '#ffb7ce',
+    'cornflower': '#6a79f7',
+    'blue violet': '#5d06e9',
+    'chocolate': '#3d1c02',
+    'greyish green': '#82a67d',
+    'scarlet': '#be0119',
+    'green yellow': '#c9ff27',
+    'dark olive': '#373e02',
+    'sienna': '#a9561e',
+    'pastel purple': '#caa0ff',
+    'terracotta': '#ca6641',
+    'aqua blue': '#02d8e9',
+    'sage green': '#88b378',
+    'blood red': '#980002',
+    'deep pink': '#cb0162',
+    'grass': '#5cac2d',
+    'moss': '#769958',
+    'pastel blue': '#a2bffe',
+    'bluish green': '#10a674',
+    'green blue': '#06b48b',
+    'dark tan': '#af884a',
+    'greenish blue': '#0b8b87',
+    'pale orange': '#ffa756',
+    'vomit': '#a2a415',
+    'forrest green': '#154406',
+    'dark lavender': '#856798',
+    'dark violet': '#34013f',
+    'purple blue': '#632de9',
+    'dark cyan': '#0a888a',
+    'olive drab': '#6f7632',
+    'pinkish': '#d46a7e',
+    'cobalt': '#1e488f',
+    'neon purple': '#bc13fe',
+    'light turquoise': '#7ef4cc',
+    'apple green': '#76cd26',
+    'dull green': '#74a662',
+    'wine': '#80013f',
+    'powder blue': '#b1d1fc',
+    'off white': '#ffffe4',
+    'electric blue': '#0652ff',
+    'dark turquoise': '#045c5a',
+    'blue purple': '#5729ce',
+    'azure': '#069af3',
+    'bright red': '#ff000d',
+    'pinkish red': '#f10c45',
+    'cornflower blue': '#5170d7',
+    'light olive': '#acbf69',
+    'grape': '#6c3461',
+    'greyish blue': '#5e819d',
+    'purplish blue': '#601ef9',
+    'yellowish green': '#b0dd16',
+    'greenish yellow': '#cdfd02',
+    'medium blue': '#2c6fbb',
+    'dusty rose': '#c0737a',
+    'light violet': '#d6b4fc',
+    'midnight blue': '#020035',
+    'bluish purple': '#703be7',
+    'red orange': '#fd3c06',
+    'dark magenta': '#960056',
+    'greenish': '#40a368',
+    'ocean blue': '#03719c',
+    'coral': '#fc5a50',
+    'cream': '#ffffc2',
+    'reddish brown': '#7f2b0a',
+    'burnt sienna': '#b04e0f',
+    'brick': '#a03623',
+    'sage': '#87ae73',
+    'grey green': '#789b73',
+    'white': '#ffffff',
+    "robin's egg blue": '#98eff9',
+    'moss green': '#658b38',
+    'steel blue': '#5a7d9a',
+    'eggplant': '#380835',
+    'light yellow': '#fffe7a',
+    'leaf green': '#5ca904',
+    'light grey': '#d8dcd6',
+    'puke': '#a5a502',
+    'pinkish purple': '#d648d7',
+    'sea blue': '#047495',
+    'pale purple': '#b790d4',
+    'slate blue': '#5b7c99',
+    'blue grey': '#607c8e',
+    'hunter green': '#0b4008',
+    'fuchsia': '#ed0dd9',
+    'crimson': '#8c000f',
+    'pale yellow': '#ffff84',
+    'ochre': '#bf9005',
+    'mustard yellow': '#d2bd0a',
+    'light red': '#ff474c',
+    'cerulean': '#0485d1',
+    'pale pink': '#ffcfdc',
+    'deep blue': '#040273',
+    'rust': '#a83c09',
+    'light teal': '#90e4c1',
+    'slate': '#516572',
+    'goldenrod': '#fac205',
+    'dark yellow': '#d5b60a',
+    'dark grey': '#363737',
+    'army green': '#4b5d16',
+    'grey blue': '#6b8ba4',
+    'seafoam': '#80f9ad',
+    'puce': '#a57e52',
+    'spring green': '#a9f971',
+    'dark orange': '#c65102',
+    'sand': '#e2ca76',
+    'pastel green': '#b0ff9d',
+    'mint': '#9ffeb0',
+    'light orange': '#fdaa48',
+    'bright pink': '#fe01b1',
+    'chartreuse': '#c1f80a',
+    'deep purple': '#36013f',
+    'dark brown': '#341c02',
+    'taupe': '#b9a281',
+    'pea green': '#8eab12',
+    'puke green': '#9aae07',
+    'kelly green': '#02ab2e',
+    'seafoam green': '#7af9ab',
+    'blue green': '#137e6d',
+    'khaki': '#aaa662',
+    'burgundy': '#610023',
+    'dark teal': '#014d4e',
+    'brick red': '#8f1402',
+    'royal purple': '#4b006e',
+    'plum': '#580f41',
+    'mint green': '#8fff9f',
+    'gold': '#dbb40c',
+    'baby blue': '#a2cffe',
+    'yellow green': '#c0fb2d',
+    'bright purple': '#be03fd',
+    'dark red': '#840000',
+    'pale blue': '#d0fefe',
+    'grass green': '#3f9b0b',
+    'navy': '#01153e',
+    'aquamarine': '#04d8b2',
+    'burnt orange': '#c04e01',
+    'neon green': '#0cff0c',
+    'bright blue': '#0165fc',
+    'rose': '#cf6275',
+    'light pink': '#ffd1df',
+    'mustard': '#ceb301',
+    'indigo': '#380282',
+    'lime': '#aaff32',
+    'sea green': '#53fca1',
+    'periwinkle': '#8e82fe',
+    'dark pink': '#cb416b',
+    'olive green': '#677a04',
+    'peach': '#ffb07c',
+    'pale green': '#c7fdb5',
+    'light brown': '#ad8150',
+    'hot pink': '#ff028d',
+    'black': '#000000',
+    'lilac': '#cea2fd',
+    'navy blue': '#001146',
+    'royal blue': '#0504aa',
+    'beige': '#e6daa6',
+    'salmon': '#ff796c',
+    'olive': '#6e750e',
+    'maroon': '#650021',
+    'bright green': '#01ff07',
+    'dark purple': '#35063e',
+    'mauve': '#ae7181',
+    'forest green': '#06470c',
+    'aqua': '#13eac9',
+    'cyan': '#00ffff',
+    'tan': '#d1b26f',
+    'dark blue': '#00035b',
+    'lavender': '#c79fef',
+    'turquoise': '#06c2ac',
+    'dark green': '#033500',
+    'violet': '#9a0eea',
+    'light purple': '#bf77f6',
+    'lime green': '#89fe05',
+    'grey': '#929591',
+    'sky blue': '#75bbfd',
+    'yellow': '#ffff14',
+    'magenta': '#c20078',
+    'light green': '#96f97b',
+    'orange': '#f97306',
+    'teal': '#029386',
+    'light blue': '#95d0fc',
+    'red': '#e50000',
+    'brown': '#653700',
+    'pink': '#ff81c0',
+    'blue': '#0343df',
+    'green': '#15b01a',
+    'purple': '#7e1e9c'}
+
+# Normalize name to "xkcd:<name>" to avoid name collisions.
+XKCD_COLORS = {'xkcd:' + name: value for name, value in XKCD_COLORS.items()}
+
+
+# https://drafts.csswg.org/css-color-4/#named-colors
+CSS4_COLORS = {
+    'aliceblue':            '#F0F8FF',
+    'antiquewhite':         '#FAEBD7',
+    'aqua':                 '#00FFFF',
+    'aquamarine':           '#7FFFD4',
+    'azure':                '#F0FFFF',
+    'beige':                '#F5F5DC',
+    'bisque':               '#FFE4C4',
+    'black':                '#000000',
+    'blanchedalmond':       '#FFEBCD',
+    'blue':                 '#0000FF',
+    'blueviolet':           '#8A2BE2',
+    'brown':                '#A52A2A',
+    'burlywood':            '#DEB887',
+    'cadetblue':            '#5F9EA0',
+    'chartreuse':           '#7FFF00',
+    'chocolate':            '#D2691E',
+    'coral':                '#FF7F50',
+    'cornflowerblue':       '#6495ED',
+    'cornsilk':             '#FFF8DC',
+    'crimson':              '#DC143C',
+    'cyan':                 '#00FFFF',
+    'darkblue':             '#00008B',
+    'darkcyan':             '#008B8B',
+    'darkgoldenrod':        '#B8860B',
+    'darkgray':             '#A9A9A9',
+    'darkgreen':            '#006400',
+    'darkgrey':             '#A9A9A9',
+    'darkkhaki':            '#BDB76B',
+    'darkmagenta':          '#8B008B',
+    'darkolivegreen':       '#556B2F',
+    'darkorange':           '#FF8C00',
+    'darkorchid':           '#9932CC',
+    'darkred':              '#8B0000',
+    'darksalmon':           '#E9967A',
+    'darkseagreen':         '#8FBC8F',
+    'darkslateblue':        '#483D8B',
+    'darkslategray':        '#2F4F4F',
+    'darkslategrey':        '#2F4F4F',
+    'darkturquoise':        '#00CED1',
+    'darkviolet':           '#9400D3',
+    'deeppink':             '#FF1493',
+    'deepskyblue':          '#00BFFF',
+    'dimgray':              '#696969',
+    'dimgrey':              '#696969',
+    'dodgerblue':           '#1E90FF',
+    'firebrick':            '#B22222',
+    'floralwhite':          '#FFFAF0',
+    'forestgreen':          '#228B22',
+    'fuchsia':              '#FF00FF',
+    'gainsboro':            '#DCDCDC',
+    'ghostwhite':           '#F8F8FF',
+    'gold':                 '#FFD700',
+    'goldenrod':            '#DAA520',
+    'gray':                 '#808080',
+    'green':                '#008000',
+    'greenyellow':          '#ADFF2F',
+    'grey':                 '#808080',
+    'honeydew':             '#F0FFF0',
+    'hotpink':              '#FF69B4',
+    'indianred':            '#CD5C5C',
+    'indigo':               '#4B0082',
+    'ivory':                '#FFFFF0',
+    'khaki':                '#F0E68C',
+    'lavender':             '#E6E6FA',
+    'lavenderblush':        '#FFF0F5',
+    'lawngreen':            '#7CFC00',
+    'lemonchiffon':         '#FFFACD',
+    'lightblue':            '#ADD8E6',
+    'lightcoral':           '#F08080',
+    'lightcyan':            '#E0FFFF',
+    'lightgoldenrodyellow': '#FAFAD2',
+    'lightgray':            '#D3D3D3',
+    'lightgreen':           '#90EE90',
+    'lightgrey':            '#D3D3D3',
+    'lightpink':            '#FFB6C1',
+    'lightsalmon':          '#FFA07A',
+    'lightseagreen':        '#20B2AA',
+    'lightskyblue':         '#87CEFA',
+    'lightslategray':       '#778899',
+    'lightslategrey':       '#778899',
+    'lightsteelblue':       '#B0C4DE',
+    'lightyellow':          '#FFFFE0',
+    'lime':                 '#00FF00',
+    'limegreen':            '#32CD32',
+    'linen':                '#FAF0E6',
+    'magenta':              '#FF00FF',
+    'maroon':               '#800000',
+    'mediumaquamarine':     '#66CDAA',
+    'mediumblue':           '#0000CD',
+    'mediumorchid':         '#BA55D3',
+    'mediumpurple':         '#9370DB',
+    'mediumseagreen':       '#3CB371',
+    'mediumslateblue':      '#7B68EE',
+    'mediumspringgreen':    '#00FA9A',
+    'mediumturquoise':      '#48D1CC',
+    'mediumvioletred':      '#C71585',
+    'midnightblue':         '#191970',
+    'mintcream':            '#F5FFFA',
+    'mistyrose':            '#FFE4E1',
+    'moccasin':             '#FFE4B5',
+    'navajowhite':          '#FFDEAD',
+    'navy':                 '#000080',
+    'oldlace':              '#FDF5E6',
+    'olive':                '#808000',
+    'olivedrab':            '#6B8E23',
+    'orange':               '#FFA500',
+    'orangered':            '#FF4500',
+    'orchid':               '#DA70D6',
+    'palegoldenrod':        '#EEE8AA',
+    'palegreen':            '#98FB98',
+    'paleturquoise':        '#AFEEEE',
+    'palevioletred':        '#DB7093',
+    'papayawhip':           '#FFEFD5',
+    'peachpuff':            '#FFDAB9',
+    'peru':                 '#CD853F',
+    'pink':                 '#FFC0CB',
+    'plum':                 '#DDA0DD',
+    'powderblue':           '#B0E0E6',
+    'purple':               '#800080',
+    'rebeccapurple':        '#663399',
+    'red':                  '#FF0000',
+    'rosybrown':            '#BC8F8F',
+    'royalblue':            '#4169E1',
+    'saddlebrown':          '#8B4513',
+    'salmon':               '#FA8072',
+    'sandybrown':           '#F4A460',
+    'seagreen':             '#2E8B57',
+    'seashell':             '#FFF5EE',
+    'sienna':               '#A0522D',
+    'silver':               '#C0C0C0',
+    'skyblue':              '#87CEEB',
+    'slateblue':            '#6A5ACD',
+    'slategray':            '#708090',
+    'slategrey':            '#708090',
+    'snow':                 '#FFFAFA',
+    'springgreen':          '#00FF7F',
+    'steelblue':            '#4682B4',
+    'tan':                  '#D2B48C',
+    'teal':                 '#008080',
+    'thistle':              '#D8BFD8',
+    'tomato':               '#FF6347',
+    'turquoise':            '#40E0D0',
+    'violet':               '#EE82EE',
+    'wheat':                '#F5DEB3',
+    'white':                '#FFFFFF',
+    'whitesmoke':           '#F5F5F5',
+    'yellow':               '#FFFF00',
+    'yellowgreen':          '#9ACD32'}

llava_next/lib/python3.10/site-packages/matplotlib/_docstring.py

@@ -0,0 +1,125 @@
+import inspect
+
+from . import _api
+
+
+def kwarg_doc(text):
+    """
+    Decorator for defining the kwdoc documentation of artist properties.
+
+    This decorator can be applied to artist property setter methods.
+    The given text is stored in a private attribute ``_kwarg_doc`` on
+    the method.  It is used to overwrite auto-generated documentation
+    in the *kwdoc list* for artists. The kwdoc list is used to document
+    ``**kwargs`` when they are properties of an artist. See e.g. the
+    ``**kwargs`` section in `.Axes.text`.
+
+    The text should contain the supported types, as well as the default
+    value if applicable, e.g.:
+
+        @_docstring.kwarg_doc("bool, default: :rc:`text.usetex`")
+        def set_usetex(self, usetex):
+
+    See Also
+    --------
+    matplotlib.artist.kwdoc
+
+    """
+    def decorator(func):
+        func._kwarg_doc = text
+        return func
+    return decorator
+
+
+class Substitution:
+    """
+    A decorator that performs %-substitution on an object's docstring.
+
+    This decorator should be robust even if ``obj.__doc__`` is None (for
+    example, if -OO was passed to the interpreter).
+
+    Usage: construct a docstring.Substitution with a sequence or dictionary
+    suitable for performing substitution; then decorate a suitable function
+    with the constructed object, e.g.::
+
+        sub_author_name = Substitution(author='Jason')
+
+        @sub_author_name
+        def some_function(x):
+            "%(author)s wrote this function"
+
+        # note that some_function.__doc__ is now "Jason wrote this function"
+
+    One can also use positional arguments::
+
+        sub_first_last_names = Substitution('Edgar Allen', 'Poe')
+
+        @sub_first_last_names
+        def some_function(x):
+            "%s %s wrote the Raven"
+    """
+    def __init__(self, *args, **kwargs):
+        if args and kwargs:
+            raise TypeError("Only positional or keyword args are allowed")
+        self.params = args or kwargs
+
+    def __call__(self, func):
+        if func.__doc__:
+            func.__doc__ = inspect.cleandoc(func.__doc__) % self.params
+        return func
+
+    def update(self, *args, **kwargs):
+        """
+        Update ``self.params`` (which must be a dict) with the supplied args.
+        """
+        self.params.update(*args, **kwargs)
+
+
+class _ArtistKwdocLoader(dict):
+    def __missing__(self, key):
+        if not key.endswith(":kwdoc"):
+            raise KeyError(key)
+        name = key[:-len(":kwdoc")]
+        from matplotlib.artist import Artist, kwdoc
+        try:
+            cls, = [cls for cls in _api.recursive_subclasses(Artist)
+                    if cls.__name__ == name]
+        except ValueError as e:
+            raise KeyError(key) from e
+        return self.setdefault(key, kwdoc(cls))
+
+
+class _ArtistPropertiesSubstitution(Substitution):
+    """
+    A `.Substitution` with two additional features:
+
+    - Substitutions of the form ``%(classname:kwdoc)s`` (ending with the
+      literal ":kwdoc" suffix) trigger lookup of an Artist subclass with the
+      given *classname*, and are substituted with the `.kwdoc` of that class.
+    - Decorating a class triggers substitution both on the class docstring and
+      on the class' ``__init__`` docstring (which is a commonly required
+      pattern for Artist subclasses).
+    """
+
+    def __init__(self):
+        self.params = _ArtistKwdocLoader()
+
+    def __call__(self, obj):
+        super().__call__(obj)
+        if isinstance(obj, type) and obj.__init__ != object.__init__:
+            self(obj.__init__)
+        return obj
+
+
+def copy(source):
+    """Copy a docstring from another source function (if present)."""
+    def do_copy(target):
+        if source.__doc__:
+            target.__doc__ = source.__doc__
+        return target
+    return do_copy
+
+
+# Create a decorator that will house the various docstring snippets reused
+# throughout Matplotlib.
+dedent_interpd = interpd = _ArtistPropertiesSubstitution()

llava_next/lib/python3.10/site-packages/matplotlib/_enums.pyi

@@ -0,0 +1,18 @@
+from enum import Enum
+
+class _AutoStringNameEnum(Enum):
+    def __hash__(self) -> int: ...
+
+class JoinStyle(str, _AutoStringNameEnum):
+    miter: str
+    round: str
+    bevel: str
+    @staticmethod
+    def demo() -> None: ...
+
+class CapStyle(str, _AutoStringNameEnum):
+    butt: str
+    projecting: str
+    round: str
+    @staticmethod
+    def demo() -> None: ...

llava_next/lib/python3.10/site-packages/matplotlib/_pylab_helpers.py

@@ -0,0 +1,134 @@
+"""
+Manage figures for the pyplot interface.
+"""
+
+import atexit
+from collections import OrderedDict
+
+
+class Gcf:
+    """
+    Singleton to maintain the relation between figures and their managers, and
+    keep track of and "active" figure and manager.
+
+    The canvas of a figure created through pyplot is associated with a figure
+    manager, which handles the interaction between the figure and the backend.
+    pyplot keeps track of figure managers using an identifier, the "figure
+    number" or "manager number" (which can actually be any hashable value);
+    this number is available as the :attr:`number` attribute of the manager.
+
+    This class is never instantiated; it consists of an `OrderedDict` mapping
+    figure/manager numbers to managers, and a set of class methods that
+    manipulate this `OrderedDict`.
+
+    Attributes
+    ----------
+    figs : OrderedDict
+        `OrderedDict` mapping numbers to managers; the active manager is at the
+        end.
+    """
+
+    figs = OrderedDict()
+
+    @classmethod
+    def get_fig_manager(cls, num):
+        """
+        If manager number *num* exists, make it the active one and return it;
+        otherwise return *None*.
+        """
+        manager = cls.figs.get(num, None)
+        if manager is not None:
+            cls.set_active(manager)
+        return manager
+
+    @classmethod
+    def destroy(cls, num):
+        """
+        Destroy manager *num* -- either a manager instance or a manager number.
+
+        In the interactive backends, this is bound to the window "destroy" and
+        "delete" events.
+
+        It is recommended to pass a manager instance, to avoid confusion when
+        two managers share the same number.
+        """
+        if all(hasattr(num, attr) for attr in ["num", "destroy"]):
+            manager = num
+            if cls.figs.get(manager.num) is manager:
+                cls.figs.pop(manager.num)
+        else:
+            try:
+                manager = cls.figs.pop(num)
+            except KeyError:
+                return
+        if hasattr(manager, "_cidgcf"):
+            manager.canvas.mpl_disconnect(manager._cidgcf)
+        manager.destroy()
+
+    @classmethod
+    def destroy_fig(cls, fig):
+        """Destroy figure *fig*."""
+        num = next((manager.num for manager in cls.figs.values()
+                    if manager.canvas.figure == fig), None)
+        if num is not None:
+            cls.destroy(num)
+
+    @classmethod
+    def destroy_all(cls):
+        """Destroy all figures."""
+        for manager in list(cls.figs.values()):
+            manager.canvas.mpl_disconnect(manager._cidgcf)
+            manager.destroy()
+        cls.figs.clear()
+
+    @classmethod
+    def has_fignum(cls, num):
+        """Return whether figure number *num* exists."""
+        return num in cls.figs
+
+    @classmethod
+    def get_all_fig_managers(cls):
+        """Return a list of figure managers."""
+        return list(cls.figs.values())
+
+    @classmethod
+    def get_num_fig_managers(cls):
+        """Return the number of figures being managed."""
+        return len(cls.figs)
+
+    @classmethod
+    def get_active(cls):
+        """Return the active manager, or *None* if there is no manager."""
+        return next(reversed(cls.figs.values())) if cls.figs else None
+
+    @classmethod
+    def _set_new_active_manager(cls, manager):
+        """Adopt *manager* into pyplot and make it the active manager."""
+        if not hasattr(manager, "_cidgcf"):
+            manager._cidgcf = manager.canvas.mpl_connect(
+                "button_press_event", lambda event: cls.set_active(manager))
+        fig = manager.canvas.figure
+        fig.number = manager.num
+        label = fig.get_label()
+        if label:
+            manager.set_window_title(label)
+        cls.set_active(manager)
+
+    @classmethod
+    def set_active(cls, manager):
+        """Make *manager* the active manager."""
+        cls.figs[manager.num] = manager
+        cls.figs.move_to_end(manager.num)
+
+    @classmethod
+    def draw_all(cls, force=False):
+        """
+        Redraw all stale managed figures, or, if *force* is True, all managed
+        figures.
+        """
+        for manager in cls.get_all_fig_managers():
+            if force or manager.canvas.figure.stale:
+                manager.canvas.draw_idle()
+
+
+atexit.register(Gcf.destroy_all)

llava_next/lib/python3.10/site-packages/matplotlib/_pylab_helpers.pyi

@@ -0,0 +1,29 @@
+from collections import OrderedDict
+
+from matplotlib.backend_bases import FigureManagerBase
+from matplotlib.figure import Figure
+
+class Gcf:
+    figs: OrderedDict[int, FigureManagerBase]
+    @classmethod
+    def get_fig_manager(cls, num: int) -> FigureManagerBase | None: ...
+    @classmethod
+    def destroy(cls, num: int | FigureManagerBase) -> None: ...
+    @classmethod
+    def destroy_fig(cls, fig: Figure) -> None: ...
+    @classmethod
+    def destroy_all(cls) -> None: ...
+    @classmethod
+    def has_fignum(cls, num: int) -> bool: ...
+    @classmethod
+    def get_all_fig_managers(cls) -> list[FigureManagerBase]: ...
+    @classmethod
+    def get_num_fig_managers(cls) -> int: ...
+    @classmethod
+    def get_active(cls) -> FigureManagerBase | None: ...
+    @classmethod
+    def _set_new_active_manager(cls, manager: FigureManagerBase) -> None: ...
+    @classmethod
+    def set_active(cls, manager: FigureManagerBase) -> None: ...
+    @classmethod
+    def draw_all(cls, force: bool = ...) -> None: ...

llava_next/lib/python3.10/site-packages/matplotlib/_qhull.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a836803f31df00f7f280085ab7873f39703c0e3c3eb5335690e8a119121145ad
+size 745280

llava_next/lib/python3.10/site-packages/matplotlib/_tight_layout.py

@@ -0,0 +1,301 @@
+"""
+Routines to adjust subplot params so that subplots are
+nicely fit in the figure. In doing so, only axis labels, tick labels, Axes
+titles and offsetboxes that are anchored to Axes are currently considered.
+
+Internally, this module assumes that the margins (left margin, etc.) which are
+differences between ``Axes.get_tightbbox`` and ``Axes.bbox`` are independent of
+Axes position. This may fail if ``Axes.adjustable`` is ``datalim`` as well as
+such cases as when left or right margin are affected by xlabel.
+"""
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib import _api, artist as martist
+from matplotlib.font_manager import FontProperties
+from matplotlib.transforms import Bbox
+
+
+def _auto_adjust_subplotpars(
+        fig, renderer, shape, span_pairs, subplot_list,
+        ax_bbox_list=None, pad=1.08, h_pad=None, w_pad=None, rect=None):
+    """
+    Return a dict of subplot parameters to adjust spacing between subplots
+    or ``None`` if resulting Axes would have zero height or width.
+
+    Note that this function ignores geometry information of subplot itself, but
+    uses what is given by the *shape* and *subplot_list* parameters.  Also, the
+    results could be incorrect if some subplots have ``adjustable=datalim``.
+
+    Parameters
+    ----------
+    shape : tuple[int, int]
+        Number of rows and columns of the grid.
+    span_pairs : list[tuple[slice, slice]]
+        List of rowspans and colspans occupied by each subplot.
+    subplot_list : list of subplots
+        List of subplots that will be used to calculate optimal subplot_params.
+    pad : float
+        Padding between the figure edge and the edges of subplots, as a
+        fraction of the font size.
+    h_pad, w_pad : float
+        Padding (height/width) between edges of adjacent subplots, as a
+        fraction of the font size.  Defaults to *pad*.
+    rect : tuple
+        (left, bottom, right, top), default: None.
+    """
+    rows, cols = shape
+
+    font_size_inch = (FontProperties(
+        size=mpl.rcParams["font.size"]).get_size_in_points() / 72)
+    pad_inch = pad * font_size_inch
+    vpad_inch = h_pad * font_size_inch if h_pad is not None else pad_inch
+    hpad_inch = w_pad * font_size_inch if w_pad is not None else pad_inch
+
+    if len(span_pairs) != len(subplot_list) or len(subplot_list) == 0:
+        raise ValueError
+
+    if rect is None:
+        margin_left = margin_bottom = margin_right = margin_top = None
+    else:
+        margin_left, margin_bottom, _right, _top = rect
+        margin_right = 1 - _right if _right else None
+        margin_top = 1 - _top if _top else None
+
+    vspaces = np.zeros((rows + 1, cols))
+    hspaces = np.zeros((rows, cols + 1))
+
+    if ax_bbox_list is None:
+        ax_bbox_list = [
+            Bbox.union([ax.get_position(original=True) for ax in subplots])
+            for subplots in subplot_list]
+
+    for subplots, ax_bbox, (rowspan, colspan) in zip(
+            subplot_list, ax_bbox_list, span_pairs):
+        if all(not ax.get_visible() for ax in subplots):
+            continue
+
+        bb = []
+        for ax in subplots:
+            if ax.get_visible():
+                bb += [martist._get_tightbbox_for_layout_only(ax, renderer)]
+
+        tight_bbox_raw = Bbox.union(bb)
+        tight_bbox = fig.transFigure.inverted().transform_bbox(tight_bbox_raw)
+
+        hspaces[rowspan, colspan.start] += ax_bbox.xmin - tight_bbox.xmin  # l
+        hspaces[rowspan, colspan.stop] += tight_bbox.xmax - ax_bbox.xmax  # r
+        vspaces[rowspan.start, colspan] += tight_bbox.ymax - ax_bbox.ymax  # t
+        vspaces[rowspan.stop, colspan] += ax_bbox.ymin - tight_bbox.ymin  # b
+
+    fig_width_inch, fig_height_inch = fig.get_size_inches()
+
+    # margins can be negative for Axes with aspect applied, so use max(, 0) to
+    # make them nonnegative.
+    if not margin_left:
+        margin_left = max(hspaces[:, 0].max(), 0) + pad_inch/fig_width_inch
+        suplabel = fig._supylabel
+        if suplabel and suplabel.get_in_layout():
+            rel_width = fig.transFigure.inverted().transform_bbox(
+                suplabel.get_window_extent(renderer)).width
+            margin_left += rel_width + pad_inch/fig_width_inch
+    if not margin_right:
+        margin_right = max(hspaces[:, -1].max(), 0) + pad_inch/fig_width_inch
+    if not margin_top:
+        margin_top = max(vspaces[0, :].max(), 0) + pad_inch/fig_height_inch
+        if fig._suptitle and fig._suptitle.get_in_layout():
+            rel_height = fig.transFigure.inverted().transform_bbox(
+                fig._suptitle.get_window_extent(renderer)).height
+            margin_top += rel_height + pad_inch/fig_height_inch
+    if not margin_bottom:
+        margin_bottom = max(vspaces[-1, :].max(), 0) + pad_inch/fig_height_inch
+        suplabel = fig._supxlabel
+        if suplabel and suplabel.get_in_layout():
+            rel_height = fig.transFigure.inverted().transform_bbox(
+                suplabel.get_window_extent(renderer)).height
+            margin_bottom += rel_height + pad_inch/fig_height_inch
+
+    if margin_left + margin_right >= 1:
+        _api.warn_external('Tight layout not applied. The left and right '
+                           'margins cannot be made large enough to '
+                           'accommodate all Axes decorations.')
+        return None
+    if margin_bottom + margin_top >= 1:
+        _api.warn_external('Tight layout not applied. The bottom and top '
+                           'margins cannot be made large enough to '
+                           'accommodate all Axes decorations.')
+        return None
+
+    kwargs = dict(left=margin_left,
+                  right=1 - margin_right,
+                  bottom=margin_bottom,
+                  top=1 - margin_top)
+
+    if cols > 1:
+        hspace = hspaces[:, 1:-1].max() + hpad_inch / fig_width_inch
+        # axes widths:
+        h_axes = (1 - margin_right - margin_left - hspace * (cols - 1)) / cols
+        if h_axes < 0:
+            _api.warn_external('Tight layout not applied. tight_layout '
+                               'cannot make Axes width small enough to '
+                               'accommodate all Axes decorations')
+            return None
+        else:
+            kwargs["wspace"] = hspace / h_axes
+    if rows > 1:
+        vspace = vspaces[1:-1, :].max() + vpad_inch / fig_height_inch
+        v_axes = (1 - margin_top - margin_bottom - vspace * (rows - 1)) / rows
+        if v_axes < 0:
+            _api.warn_external('Tight layout not applied. tight_layout '
+                               'cannot make Axes height small enough to '
+                               'accommodate all Axes decorations.')
+            return None
+        else:
+            kwargs["hspace"] = vspace / v_axes
+
+    return kwargs
+
+
+def get_subplotspec_list(axes_list, grid_spec=None):
+    """
+    Return a list of subplotspec from the given list of Axes.
+
+    For an instance of Axes that does not support subplotspec, None is inserted
+    in the list.
+
+    If grid_spec is given, None is inserted for those not from the given
+    grid_spec.
+    """
+    subplotspec_list = []
+    for ax in axes_list:
+        axes_or_locator = ax.get_axes_locator()
+        if axes_or_locator is None:
+            axes_or_locator = ax
+
+        if hasattr(axes_or_locator, "get_subplotspec"):
+            subplotspec = axes_or_locator.get_subplotspec()
+            if subplotspec is not None:
+                subplotspec = subplotspec.get_topmost_subplotspec()
+                gs = subplotspec.get_gridspec()
+                if grid_spec is not None:
+                    if gs != grid_spec:
+                        subplotspec = None
+                elif gs.locally_modified_subplot_params():
+                    subplotspec = None
+        else:
+            subplotspec = None
+
+        subplotspec_list.append(subplotspec)
+
+    return subplotspec_list
+
+
+def get_tight_layout_figure(fig, axes_list, subplotspec_list, renderer,
+                            pad=1.08, h_pad=None, w_pad=None, rect=None):
+    """
+    Return subplot parameters for tight-layouted-figure with specified padding.
+
+    Parameters
+    ----------
+    fig : Figure
+    axes_list : list of Axes
+    subplotspec_list : list of `.SubplotSpec`
+        The subplotspecs of each Axes.
+    renderer : renderer
+    pad : float
+        Padding between the figure edge and the edges of subplots, as a
+        fraction of the font size.
+    h_pad, w_pad : float
+        Padding (height/width) between edges of adjacent subplots.  Defaults to
+        *pad*.
+    rect : tuple (left, bottom, right, top), default: None.
+        rectangle in normalized figure coordinates
+        that the whole subplots area (including labels) will fit into.
+        Defaults to using the entire figure.
+
+    Returns
+    -------
+    subplotspec or None
+        subplotspec kwargs to be passed to `.Figure.subplots_adjust` or
+        None if tight_layout could not be accomplished.
+    """
+
+    # Multiple Axes can share same subplotspec (e.g., if using axes_grid1);
+    # we need to group them together.
+    ss_to_subplots = {ss: [] for ss in subplotspec_list}
+    for ax, ss in zip(axes_list, subplotspec_list):
+        ss_to_subplots[ss].append(ax)
+    if ss_to_subplots.pop(None, None):
+        _api.warn_external(
+            "This figure includes Axes that are not compatible with "
+            "tight_layout, so results might be incorrect.")
+    if not ss_to_subplots:
+        return {}
+    subplot_list = list(ss_to_subplots.values())
+    ax_bbox_list = [ss.get_position(fig) for ss in ss_to_subplots]
+
+    max_nrows = max(ss.get_gridspec().nrows for ss in ss_to_subplots)
+    max_ncols = max(ss.get_gridspec().ncols for ss in ss_to_subplots)
+
+    span_pairs = []
+    for ss in ss_to_subplots:
+        # The intent here is to support Axes from different gridspecs where
+        # one's nrows (or ncols) is a multiple of the other (e.g. 2 and 4),
+        # but this doesn't actually work because the computed wspace, in
+        # relative-axes-height, corresponds to different physical spacings for
+        # the 2-row grid and the 4-row grid.  Still, this code is left, mostly
+        # for backcompat.
+        rows, cols = ss.get_gridspec().get_geometry()
+        div_row, mod_row = divmod(max_nrows, rows)
+        div_col, mod_col = divmod(max_ncols, cols)
+        if mod_row != 0:
+            _api.warn_external('tight_layout not applied: number of rows '
+                               'in subplot specifications must be '
+                               'multiples of one another.')
+            return {}
+        if mod_col != 0:
+            _api.warn_external('tight_layout not applied: number of '
+                               'columns in subplot specifications must be '
+                               'multiples of one another.')
+            return {}
+        span_pairs.append((
+            slice(ss.rowspan.start * div_row, ss.rowspan.stop * div_row),
+            slice(ss.colspan.start * div_col, ss.colspan.stop * div_col)))
+
+    kwargs = _auto_adjust_subplotpars(fig, renderer,
+                                      shape=(max_nrows, max_ncols),
+                                      span_pairs=span_pairs,
+                                      subplot_list=subplot_list,
+                                      ax_bbox_list=ax_bbox_list,
+                                      pad=pad, h_pad=h_pad, w_pad=w_pad)
+
+    # kwargs can be none if tight_layout fails...
+    if rect is not None and kwargs is not None:
+        # if rect is given, the whole subplots area (including
+        # labels) will fit into the rect instead of the
+        # figure. Note that the rect argument of
+        # *auto_adjust_subplotpars* specify the area that will be
+        # covered by the total area of axes.bbox. Thus we call
+        # auto_adjust_subplotpars twice, where the second run
+        # with adjusted rect parameters.
+
+        left, bottom, right, top = rect
+        if left is not None:
+            left += kwargs["left"]
+        if bottom is not None:
+            bottom += kwargs["bottom"]
+        if right is not None:
+            right -= (1 - kwargs["right"])
+        if top is not None:
+            top -= (1 - kwargs["top"])
+
+        kwargs = _auto_adjust_subplotpars(fig, renderer,
+                                          shape=(max_nrows, max_ncols),
+                                          span_pairs=span_pairs,
+                                          subplot_list=subplot_list,
+                                          ax_bbox_list=ax_bbox_list,
+                                          pad=pad, h_pad=h_pad, w_pad=w_pad,
+                                          rect=(left, bottom, right, top))
+
+    return kwargs

llava_next/lib/python3.10/site-packages/matplotlib/_tri.pyi

@@ -0,0 +1,26 @@
+# This is a private module implemented in C++
+# As such these type stubs are overly generic, but here to allow these types
+# as return types for public methods
+from typing import Any, final
+
+@final
+class TrapezoidMapTriFinder:
+    def __init__(self, *args, **kwargs) -> None: ...
+    def find_many(self, *args, **kwargs) -> Any: ...
+    def get_tree_stats(self, *args, **kwargs) -> Any: ...
+    def initialize(self, *args, **kwargs) -> Any: ...
+    def print_tree(self, *args, **kwargs) -> Any: ...
+
+@final
+class TriContourGenerator:
+    def __init__(self, *args, **kwargs) -> None: ...
+    def create_contour(self, *args, **kwargs) -> Any: ...
+    def create_filled_contour(self, *args, **kwargs) -> Any: ...
+
+@final
+class Triangulation:
+    def __init__(self, *args, **kwargs) -> None: ...
+    def calculate_plane_coefficients(self, *args, **kwargs) -> Any: ...
+    def get_edges(self, *args, **kwargs) -> Any: ...
+    def get_neighbors(self, *args, **kwargs) -> Any: ...
+    def set_mask(self, *args, **kwargs) -> Any: ...

llava_next/lib/python3.10/site-packages/matplotlib/_version.py

@@ -0,0 +1 @@
+version = "3.9.2"

llava_next/lib/python3.10/site-packages/matplotlib/axis.pyi

@@ -0,0 +1,280 @@
+from collections.abc import Callable, Iterable, Sequence
+import datetime
+from typing import Any, Literal, overload
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+import matplotlib.artist as martist
+from matplotlib import cbook
+from matplotlib.axes import Axes
+from matplotlib.backend_bases import RendererBase
+from matplotlib.lines import Line2D
+from matplotlib.text import Text
+from matplotlib.ticker import Locator, Formatter
+from matplotlib.transforms import Transform, Bbox
+from matplotlib.typing import ColorType
+
+
+GRIDLINE_INTERPOLATION_STEPS: int
+
+class Tick(martist.Artist):
+    axes: Axes
+    tick1line: Line2D
+    tick2line: Line2D
+    gridline: Line2D
+    label1: Text
+    label2: Text
+    def __init__(
+        self,
+        axes: Axes,
+        loc: float,
+        *,
+        size: float | None = ...,
+        width: float | None = ...,
+        color: ColorType | None = ...,
+        tickdir: Literal["in", "inout", "out"] | None = ...,
+        pad: float | None = ...,
+        labelsize: float | None = ...,
+        labelcolor: ColorType | None = ...,
+        labelfontfamily: str | Sequence[str] | None = ...,
+        zorder: float | None = ...,
+        gridOn: bool | None = ...,
+        tick1On: bool = ...,
+        tick2On: bool = ...,
+        label1On: bool = ...,
+        label2On: bool = ...,
+        major: bool = ...,
+        labelrotation: float = ...,
+        grid_color: ColorType | None = ...,
+        grid_linestyle: str | None = ...,
+        grid_linewidth: float | None = ...,
+        grid_alpha: float | None = ...,
+        **kwargs
+    ) -> None: ...
+    def get_tickdir(self) -> Literal["in", "inout", "out"]: ...
+    def get_tick_padding(self) -> float: ...
+    def get_children(self) -> list[martist.Artist]: ...
+    stale: bool
+    def set_pad(self, val: float) -> None: ...
+    def get_pad(self) -> None: ...
+    def get_loc(self) -> float: ...
+    def set_label1(self, s: object) -> None: ...
+    def set_label(self, s: object) -> None: ...
+    def set_label2(self, s: object) -> None: ...
+    def set_url(self, url: str | None) -> None: ...
+    def get_view_interval(self) -> ArrayLike: ...
+    def update_position(self, loc: float) -> None: ...
+
+class XTick(Tick):
+    __name__: str
+    def __init__(self, *args, **kwargs) -> None: ...
+    stale: bool
+    def update_position(self, loc: float) -> None: ...
+    def get_view_interval(self) -> np.ndarray: ...
+
+class YTick(Tick):
+    __name__: str
+    def __init__(self, *args, **kwargs) -> None: ...
+    stale: bool
+    def update_position(self, loc: float) -> None: ...
+    def get_view_interval(self) -> np.ndarray: ...
+
+class Ticker:
+    def __init__(self) -> None: ...
+    @property
+    def locator(self) -> Locator | None: ...
+    @locator.setter
+    def locator(self, locator: Locator) -> None: ...
+    @property
+    def formatter(self) -> Formatter | None: ...
+    @formatter.setter
+    def formatter(self, formatter: Formatter) -> None: ...
+
+class _LazyTickList:
+    def __init__(self, major: bool) -> None: ...
+    # Replace return with Self when py3.9 is dropped
+    @overload
+    def __get__(self, instance: None, owner: None) -> _LazyTickList: ...
+    @overload
+    def __get__(self, instance: Axis, owner: type[Axis]) -> list[Tick]: ...
+
+class Axis(martist.Artist):
+    OFFSETTEXTPAD: int
+    isDefault_label: bool
+    axes: Axes
+    major: Ticker
+    minor: Ticker
+    callbacks: cbook.CallbackRegistry
+    label: Text
+    offsetText: Text
+    labelpad: float
+    pickradius: float
+    def __init__(self, axes, *, pickradius: float = ...,
+                 clear: bool = ...) -> None: ...
+    @property
+    def isDefault_majloc(self) -> bool: ...
+    @isDefault_majloc.setter
+    def isDefault_majloc(self, value: bool) -> None: ...
+    @property
+    def isDefault_majfmt(self) -> bool: ...
+    @isDefault_majfmt.setter
+    def isDefault_majfmt(self, value: bool) -> None: ...
+    @property
+    def isDefault_minloc(self) -> bool: ...
+    @isDefault_minloc.setter
+    def isDefault_minloc(self, value: bool) -> None: ...
+    @property
+    def isDefault_minfmt(self) -> bool: ...
+    @isDefault_minfmt.setter
+    def isDefault_minfmt(self, value: bool) -> None: ...
+    majorTicks: _LazyTickList
+    minorTicks: _LazyTickList
+    def get_remove_overlapping_locs(self) -> bool: ...
+    def set_remove_overlapping_locs(self, val: bool) -> None: ...
+    @property
+    def remove_overlapping_locs(self) -> bool: ...
+    @remove_overlapping_locs.setter
+    def remove_overlapping_locs(self, val: bool) -> None: ...
+    stale: bool
+    def set_label_coords(
+        self, x: float, y: float, transform: Transform | None = ...
+    ) -> None: ...
+    def get_transform(self) -> Transform: ...
+    def get_scale(self) -> str: ...
+    def limit_range_for_scale(
+        self, vmin: float, vmax: float
+    ) -> tuple[float, float]: ...
+    def get_children(self) -> list[martist.Artist]: ...
+    # TODO units
+    converter: Any
+    units: Any
+    def clear(self) -> None: ...
+    def reset_ticks(self) -> None: ...
+    def minorticks_on(self) -> None: ...
+    def minorticks_off(self) -> None: ...
+    def set_tick_params(
+        self,
+        which: Literal["major", "minor", "both"] = ...,
+        reset: bool = ...,
+        **kwargs
+    ) -> None: ...
+    def get_tick_params(
+        self, which: Literal["major", "minor"] = ...
+    ) -> dict[str, Any]: ...
+    def get_view_interval(self) -> tuple[float, float]: ...
+    def set_view_interval(
+        self, vmin: float, vmax: float, ignore: bool = ...
+    ) -> None: ...
+    def get_data_interval(self) -> tuple[float, float]: ...
+    def set_data_interval(
+        self, vmin: float, vmax: float, ignore: bool = ...
+    ) -> None: ...
+    def get_inverted(self) -> bool: ...
+    def set_inverted(self, inverted: bool) -> None: ...
+    def set_default_intervals(self) -> None: ...
+    def get_tightbbox(
+        self, renderer: RendererBase | None = ..., *, for_layout_only: bool = ...
+    ) -> Bbox | None: ...
+    def get_tick_padding(self) -> float: ...
+    def get_gridlines(self) -> list[Line2D]: ...
+    def get_label(self) -> Text: ...
+    def get_offset_text(self) -> Text: ...
+    def get_pickradius(self) -> float: ...
+    def get_majorticklabels(self) -> list[Text]: ...
+    def get_minorticklabels(self) -> list[Text]: ...
+    def get_ticklabels(
+        self, minor: bool = ..., which: Literal["major", "minor", "both"] | None = ...
+    ) -> list[Text]: ...
+    def get_majorticklines(self) -> list[Line2D]: ...
+    def get_minorticklines(self) -> list[Line2D]: ...
+    def get_ticklines(self, minor: bool = ...) -> list[Line2D]: ...
+    def get_majorticklocs(self) -> np.ndarray: ...
+    def get_minorticklocs(self) -> np.ndarray: ...
+    def get_ticklocs(self, *, minor: bool = ...) -> np.ndarray: ...
+    def get_ticks_direction(self, minor: bool = ...) -> np.ndarray: ...
+    def get_label_text(self) -> str: ...
+    def get_major_locator(self) -> Locator: ...
+    def get_minor_locator(self) -> Locator: ...
+    def get_major_formatter(self) -> Formatter: ...
+    def get_minor_formatter(self) -> Formatter: ...
+    def get_major_ticks(self, numticks: int | None = ...) -> list[Tick]: ...
+    def get_minor_ticks(self, numticks: int | None = ...) -> list[Tick]: ...
+    def grid(
+        self,
+        visible: bool | None = ...,
+        which: Literal["major", "minor", "both"] = ...,
+        **kwargs
+    ) -> None: ...
+    # TODO units
+    def update_units(self, data): ...
+    def have_units(self) -> bool: ...
+    def convert_units(self, x): ...
+    def set_units(self, u) -> None: ...
+    def get_units(self): ...
+    def set_label_text(
+        self, label: str, fontdict: dict[str, Any] | None = ..., **kwargs
+    ) -> Text: ...
+    def set_major_formatter(
+        self, formatter: Formatter | str | Callable[[float, float], str]
+    ) -> None: ...
+    def set_minor_formatter(
+        self, formatter: Formatter | str | Callable[[float, float], str]
+    ) -> None: ...
+    def set_major_locator(self, locator: Locator) -> None: ...
+    def set_minor_locator(self, locator: Locator) -> None: ...
+    def set_pickradius(self, pickradius: float) -> None: ...
+    def set_ticklabels(
+        self,
+        labels: Iterable[str | Text],
+        *,
+        minor: bool = ...,
+        fontdict: dict[str, Any] | None = ...,
+        **kwargs
+    ) -> list[Text]: ...
+    def set_ticks(
+        self,
+        ticks: ArrayLike,
+        labels: Iterable[str] | None = ...,
+        *,
+        minor: bool = ...,
+        **kwargs
+    ) -> list[Tick]: ...
+    def axis_date(self, tz: str | datetime.tzinfo | None = ...) -> None: ...
+    def get_tick_space(self) -> int: ...
+    def get_label_position(self) -> Literal["top", "bottom"]: ...
+    def set_label_position(
+        self, position: Literal["top", "bottom", "left", "right"]
+    ) -> None: ...
+    def get_minpos(self) -> float: ...
+
+class XAxis(Axis):
+    __name__: str
+    axis_name: str
+    def __init__(self, *args, **kwargs) -> None: ...
+    label_position: Literal["bottom", "top"]
+    stale: bool
+    def set_label_position(self, position: Literal["bottom", "top"]) -> None: ...  # type: ignore[override]
+    def set_ticks_position(
+        self, position: Literal["top", "bottom", "both", "default", "none"]
+    ) -> None: ...
+    def tick_top(self) -> None: ...
+    def tick_bottom(self) -> None: ...
+    def get_ticks_position(self) -> Literal["top", "bottom", "default", "unknown"]: ...
+    def get_tick_space(self) -> int: ...
+
+class YAxis(Axis):
+    __name__: str
+    axis_name: str
+    def __init__(self, *args, **kwargs) -> None: ...
+    label_position: Literal["left", "right"]
+    stale: bool
+    def set_label_position(self, position: Literal["left", "right"]) -> None: ...  # type: ignore[override]
+    def set_offset_position(self, position: Literal["left", "right"]) -> None: ...
+    def set_ticks_position(
+        self, position: Literal["left", "right", "both", "default", "none"]
+    ) -> None: ...
+    def tick_right(self) -> None: ...
+    def tick_left(self) -> None: ...
+    def get_ticks_position(self) -> Literal["left", "right", "default", "unknown"]: ...
+    def get_tick_space(self) -> int: ...

llava_next/lib/python3.10/site-packages/matplotlib/cbook.pyi

@@ -0,0 +1,186 @@
+import collections.abc
+from collections.abc import Callable, Collection, Generator, Iterable, Iterator
+import contextlib
+import os
+from pathlib import Path
+
+from matplotlib.artist import Artist
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+from typing import (
+    Any,
+    Generic,
+    IO,
+    Literal,
+    TypeVar,
+    overload,
+)
+
+_T = TypeVar("_T")
+
+def _get_running_interactive_framework() -> str | None: ...
+
+class CallbackRegistry:
+    exception_handler: Callable[[Exception], Any]
+    callbacks: dict[Any, dict[int, Any]]
+    def __init__(
+        self,
+        exception_handler: Callable[[Exception], Any] | None = ...,
+        *,
+        signals: Iterable[Any] | None = ...,
+    ) -> None: ...
+    def connect(self, signal: Any, func: Callable) -> int: ...
+    def disconnect(self, cid: int) -> None: ...
+    def process(self, s: Any, *args, **kwargs) -> None: ...
+    def blocked(
+        self, *, signal: Any | None = ...
+    ) -> contextlib.AbstractContextManager[None]: ...
+
+class silent_list(list[_T]):
+    type: str | None
+    def __init__(self, type: str | None, seq: Iterable[_T] | None = ...) -> None: ...
+
+def strip_math(s: str) -> str: ...
+def is_writable_file_like(obj: Any) -> bool: ...
+def file_requires_unicode(x: Any) -> bool: ...
+@overload
+def to_filehandle(
+    fname: str | os.PathLike | IO,
+    flag: str = ...,
+    return_opened: Literal[False] = ...,
+    encoding: str | None = ...,
+) -> IO: ...
+@overload
+def to_filehandle(
+    fname: str | os.PathLike | IO,
+    flag: str,
+    return_opened: Literal[True],
+    encoding: str | None = ...,
+) -> tuple[IO, bool]: ...
+@overload
+def to_filehandle(
+    fname: str | os.PathLike | IO,
+    *,  # if flag given, will match previous sig
+    return_opened: Literal[True],
+    encoding: str | None = ...,
+) -> tuple[IO, bool]: ...
+def open_file_cm(
+    path_or_file: str | os.PathLike | IO,
+    mode: str = ...,
+    encoding: str | None = ...,
+) -> contextlib.AbstractContextManager[IO]: ...
+def is_scalar_or_string(val: Any) -> bool: ...
+@overload
+def get_sample_data(
+    fname: str | os.PathLike, asfileobj: Literal[True] = ..., *, np_load: Literal[True]
+) -> np.ndarray: ...
+@overload
+def get_sample_data(
+    fname: str | os.PathLike,
+    asfileobj: Literal[True] = ...,
+    *,
+    np_load: Literal[False] = ...,
+) -> IO: ...
+@overload
+def get_sample_data(
+    fname: str | os.PathLike, asfileobj: Literal[False], *, np_load: bool = ...
+) -> str: ...
+def _get_data_path(*args: Path | str) -> Path: ...
+def flatten(
+    seq: Iterable[Any], scalarp: Callable[[Any], bool] = ...
+) -> Generator[Any, None, None]: ...
+
+class Stack(Generic[_T]):
+    def __init__(self, default: _T | None = ...) -> None: ...
+    def __call__(self) -> _T: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, ind: int) -> _T: ...
+    def forward(self) -> _T: ...
+    def back(self) -> _T: ...
+    def push(self, o: _T) -> _T: ...
+    def home(self) -> _T: ...
+    def empty(self) -> bool: ...
+    def clear(self) -> None: ...
+    def bubble(self, o: _T) -> _T: ...
+    def remove(self, o: _T) -> None: ...
+
+def safe_masked_invalid(x: ArrayLike, copy: bool = ...) -> np.ndarray: ...
+def print_cycles(
+    objects: Iterable[Any], outstream: IO = ..., show_progress: bool = ...
+) -> None: ...
+
+class Grouper(Generic[_T]):
+    def __init__(self, init: Iterable[_T] = ...) -> None: ...
+    def __contains__(self, item: _T) -> bool: ...
+    def clean(self) -> None: ...
+    def join(self, a: _T, *args: _T) -> None: ...
+    def joined(self, a: _T, b: _T) -> bool: ...
+    def remove(self, a: _T) -> None: ...
+    def __iter__(self) -> Iterator[list[_T]]: ...
+    def get_siblings(self, a: _T) -> list[_T]: ...
+
+class GrouperView(Generic[_T]):
+    def __init__(self, grouper: Grouper[_T]) -> None: ...
+    def __contains__(self, item: _T) -> bool: ...
+    def __iter__(self) -> Iterator[list[_T]]: ...
+    def joined(self, a: _T, b: _T) -> bool: ...
+    def get_siblings(self, a: _T) -> list[_T]: ...
+
+def simple_linear_interpolation(a: ArrayLike, steps: int) -> np.ndarray: ...
+def delete_masked_points(*args): ...
+def _broadcast_with_masks(*args: ArrayLike, compress: bool = ...) -> list[ArrayLike]: ...
+def boxplot_stats(
+    X: ArrayLike,
+    whis: float | tuple[float, float] = ...,
+    bootstrap: int | None = ...,
+    labels: ArrayLike | None = ...,
+    autorange: bool = ...,
+) -> list[dict[str, Any]]: ...
+
+ls_mapper: dict[str, str]
+ls_mapper_r: dict[str, str]
+
+def contiguous_regions(mask: ArrayLike) -> list[np.ndarray]: ...
+def is_math_text(s: str) -> bool: ...
+def violin_stats(
+    X: ArrayLike, method: Callable, points: int = ..., quantiles: ArrayLike | None = ...
+) -> list[dict[str, Any]]: ...
+def pts_to_prestep(x: ArrayLike, *args: ArrayLike) -> np.ndarray: ...
+def pts_to_poststep(x: ArrayLike, *args: ArrayLike) -> np.ndarray: ...
+def pts_to_midstep(x: np.ndarray, *args: np.ndarray) -> np.ndarray: ...
+
+STEP_LOOKUP_MAP: dict[str, Callable]
+
+def index_of(y: float | ArrayLike) -> tuple[np.ndarray, np.ndarray]: ...
+def safe_first_element(obj: Collection[_T]) -> _T: ...
+def sanitize_sequence(data): ...
+def normalize_kwargs(
+    kw: dict[str, Any],
+    alias_mapping: dict[str, list[str]] | type[Artist] | Artist | None = ...,
+) -> dict[str, Any]: ...
+def _lock_path(path: str | os.PathLike) -> contextlib.AbstractContextManager[None]: ...
+def _str_equal(obj: Any, s: str) -> bool: ...
+def _str_lower_equal(obj: Any, s: str) -> bool: ...
+def _array_perimeter(arr: np.ndarray) -> np.ndarray: ...
+def _unfold(arr: np.ndarray, axis: int, size: int, step: int) -> np.ndarray: ...
+def _array_patch_perimeters(x: np.ndarray, rstride: int, cstride: int) -> np.ndarray: ...
+def _setattr_cm(obj: Any, **kwargs) -> contextlib.AbstractContextManager[None]: ...
+
+class _OrderedSet(collections.abc.MutableSet):
+    def __init__(self) -> None: ...
+    def __contains__(self, key) -> bool: ...
+    def __iter__(self): ...
+    def __len__(self) -> int: ...
+    def add(self, key) -> None: ...
+    def discard(self, key) -> None: ...
+
+def _setup_new_guiapp() -> None: ...
+def _format_approx(number: float, precision: int) -> str: ...
+def _g_sig_digits(value: float, delta: float) -> int: ...
+def _unikey_or_keysym_to_mplkey(unikey: str, keysym: str) -> str: ...
+def _is_torch_array(x: Any) -> bool: ...
+def _is_jax_array(x: Any) -> bool: ...
+def _unpack_to_numpy(x: Any) -> Any: ...
+def _auto_format_str(fmt: str, value: Any) -> str: ...

llava_next/lib/python3.10/site-packages/matplotlib/cm.py

@@ -0,0 +1,664 @@
+"""
+Builtin colormaps, colormap handling utilities, and the `ScalarMappable` mixin.
+
+.. seealso::
+
+  :doc:`/gallery/color/colormap_reference` for a list of builtin colormaps.
+
+  :ref:`colormap-manipulation` for examples of how to make
+  colormaps.
+
+  :ref:`colormaps` an in-depth discussion of choosing
+  colormaps.
+
+  :ref:`colormapnorms` for more details about data normalization.
+"""
+
+from collections.abc import Mapping
+import functools
+
+import numpy as np
+from numpy import ma
+
+import matplotlib as mpl
+from matplotlib import _api, colors, cbook, scale
+from matplotlib._cm import datad
+from matplotlib._cm_listed import cmaps as cmaps_listed
+
+
+_LUTSIZE = mpl.rcParams['image.lut']
+
+
+def _gen_cmap_registry():
+    """
+    Generate a dict mapping standard colormap names to standard colormaps, as
+    well as the reversed colormaps.
+    """
+    cmap_d = {**cmaps_listed}
+    for name, spec in datad.items():
+        cmap_d[name] = (  # Precache the cmaps at a fixed lutsize..
+            colors.LinearSegmentedColormap(name, spec, _LUTSIZE)
+            if 'red' in spec else
+            colors.ListedColormap(spec['listed'], name)
+            if 'listed' in spec else
+            colors.LinearSegmentedColormap.from_list(name, spec, _LUTSIZE))
+
+    # Register colormap aliases for gray and grey.
+    cmap_d['grey'] = cmap_d['gray']
+    cmap_d['gist_grey'] = cmap_d['gist_gray']
+    cmap_d['gist_yerg'] = cmap_d['gist_yarg']
+    cmap_d['Grays'] = cmap_d['Greys']
+
+    # Generate reversed cmaps.
+    for cmap in list(cmap_d.values()):
+        rmap = cmap.reversed()
+        cmap_d[rmap.name] = rmap
+    return cmap_d
+
+
+class ColormapRegistry(Mapping):
+    r"""
+    Container for colormaps that are known to Matplotlib by name.
+
+    The universal registry instance is `matplotlib.colormaps`. There should be
+    no need for users to instantiate `.ColormapRegistry` themselves.
+
+    Read access uses a dict-like interface mapping names to `.Colormap`\s::
+
+        import matplotlib as mpl
+        cmap = mpl.colormaps['viridis']
+
+    Returned `.Colormap`\s are copies, so that their modification does not
+    change the global definition of the colormap.
+
+    Additional colormaps can be added via `.ColormapRegistry.register`::
+
+        mpl.colormaps.register(my_colormap)
+
+    To get a list of all registered colormaps, you can do::
+
+        from matplotlib import colormaps
+        list(colormaps)
+    """
+    def __init__(self, cmaps):
+        self._cmaps = cmaps
+        self._builtin_cmaps = tuple(cmaps)
+
+    def __getitem__(self, item):
+        try:
+            return self._cmaps[item].copy()
+        except KeyError:
+            raise KeyError(f"{item!r} is not a known colormap name") from None
+
+    def __iter__(self):
+        return iter(self._cmaps)
+
+    def __len__(self):
+        return len(self._cmaps)
+
+    def __str__(self):
+        return ('ColormapRegistry; available colormaps:\n' +
+                ', '.join(f"'{name}'" for name in self))
+
+    def __call__(self):
+        """
+        Return a list of the registered colormap names.
+
+        This exists only for backward-compatibility in `.pyplot` which had a
+        ``plt.colormaps()`` method. The recommended way to get this list is
+        now ``list(colormaps)``.
+        """
+        return list(self)
+
+    def register(self, cmap, *, name=None, force=False):
+        """
+        Register a new colormap.
+
+        The colormap name can then be used as a string argument to any ``cmap``
+        parameter in Matplotlib. It is also available in ``pyplot.get_cmap``.
+
+        The colormap registry stores a copy of the given colormap, so that
+        future changes to the original colormap instance do not affect the
+        registered colormap. Think of this as the registry taking a snapshot
+        of the colormap at registration.
+
+        Parameters
+        ----------
+        cmap : matplotlib.colors.Colormap
+            The colormap to register.
+
+        name : str, optional
+            The name for the colormap. If not given, ``cmap.name`` is used.
+
+        force : bool, default: False
+            If False, a ValueError is raised if trying to overwrite an already
+            registered name. True supports overwriting registered colormaps
+            other than the builtin colormaps.
+        """
+        _api.check_isinstance(colors.Colormap, cmap=cmap)
+
+        name = name or cmap.name
+        if name in self:
+            if not force:
+                # don't allow registering an already existing cmap
+                # unless explicitly asked to
+                raise ValueError(
+                    f'A colormap named "{name}" is already registered.')
+            elif name in self._builtin_cmaps:
+                # We don't allow overriding a builtin.
+                raise ValueError("Re-registering the builtin cmap "
+                                 f"{name!r} is not allowed.")
+
+            # Warn that we are updating an already existing colormap
+            _api.warn_external(f"Overwriting the cmap {name!r} "
+                               "that was already in the registry.")
+
+        self._cmaps[name] = cmap.copy()
+        # Someone may set the extremes of a builtin colormap and want to register it
+        # with a different name for future lookups. The object would still have the
+        # builtin name, so we should update it to the registered name
+        if self._cmaps[name].name != name:
+            self._cmaps[name].name = name
+
+    def unregister(self, name):
+        """
+        Remove a colormap from the registry.
+
+        You cannot remove built-in colormaps.
+
+        If the named colormap is not registered, returns with no error, raises
+        if you try to de-register a default colormap.
+
+        .. warning::
+
+            Colormap names are currently a shared namespace that may be used
+            by multiple packages. Use `unregister` only if you know you
+            have registered that name before. In particular, do not
+            unregister just in case to clean the name before registering a
+            new colormap.
+
+        Parameters
+        ----------
+        name : str
+            The name of the colormap to be removed.
+
+        Raises
+        ------
+        ValueError
+            If you try to remove a default built-in colormap.
+        """
+        if name in self._builtin_cmaps:
+            raise ValueError(f"cannot unregister {name!r} which is a builtin "
+                             "colormap.")
+        self._cmaps.pop(name, None)
+
+    def get_cmap(self, cmap):
+        """
+        Return a color map specified through *cmap*.
+
+        Parameters
+        ----------
+        cmap : str or `~matplotlib.colors.Colormap` or None
+
+            - if a `.Colormap`, return it
+            - if a string, look it up in ``mpl.colormaps``
+            - if None, return the Colormap defined in :rc:`image.cmap`
+
+        Returns
+        -------
+        Colormap
+        """
+        # get the default color map
+        if cmap is None:
+            return self[mpl.rcParams["image.cmap"]]
+
+        # if the user passed in a Colormap, simply return it
+        if isinstance(cmap, colors.Colormap):
+            return cmap
+        if isinstance(cmap, str):
+            _api.check_in_list(sorted(_colormaps), cmap=cmap)
+            # otherwise, it must be a string so look it up
+            return self[cmap]
+        raise TypeError(
+            'get_cmap expects None or an instance of a str or Colormap . ' +
+            f'you passed {cmap!r} of type {type(cmap)}'
+        )
+
+
+# public access to the colormaps should be via `matplotlib.colormaps`. For now,
+# we still create the registry here, but that should stay an implementation
+# detail.
+_colormaps = ColormapRegistry(_gen_cmap_registry())
+globals().update(_colormaps)
+
+
+# This is an exact copy of pyplot.get_cmap(). It was removed in 3.9, but apparently
+# caused more user trouble than expected. Re-added for 3.9.1 and extended the
+# deprecation period for two additional minor releases.
+@_api.deprecated(
+    '3.7',
+    removal='3.11',
+    alternative="``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()``"
+                " or ``pyplot.get_cmap()``"
+    )
+def get_cmap(name=None, lut=None):
+    """
+    Get a colormap instance, defaulting to rc values if *name* is None.
+
+    Parameters
+    ----------
+    name : `~matplotlib.colors.Colormap` or str or None, default: None
+        If a `.Colormap` instance, it will be returned. Otherwise, the name of
+        a colormap known to Matplotlib, which will be resampled by *lut*. The
+        default, None, means :rc:`image.cmap`.
+    lut : int or None, default: None
+        If *name* is not already a Colormap instance and *lut* is not None, the
+        colormap will be resampled to have *lut* entries in the lookup table.
+
+    Returns
+    -------
+    Colormap
+    """
+    if name is None:
+        name = mpl.rcParams['image.cmap']
+    if isinstance(name, colors.Colormap):
+        return name
+    _api.check_in_list(sorted(_colormaps), name=name)
+    if lut is None:
+        return _colormaps[name]
+    else:
+        return _colormaps[name].resampled(lut)
+
+
+def _auto_norm_from_scale(scale_cls):
+    """
+    Automatically generate a norm class from *scale_cls*.
+
+    This differs from `.colors.make_norm_from_scale` in the following points:
+
+    - This function is not a class decorator, but directly returns a norm class
+      (as if decorating `.Normalize`).
+    - The scale is automatically constructed with ``nonpositive="mask"``, if it
+      supports such a parameter, to work around the difference in defaults
+      between standard scales (which use "clip") and norms (which use "mask").
+
+    Note that ``make_norm_from_scale`` caches the generated norm classes
+    (not the instances) and reuses them for later calls.  For example,
+    ``type(_auto_norm_from_scale("log")) == LogNorm``.
+    """
+    # Actually try to construct an instance, to verify whether
+    # ``nonpositive="mask"`` is supported.
+    try:
+        norm = colors.make_norm_from_scale(
+            functools.partial(scale_cls, nonpositive="mask"))(
+            colors.Normalize)()
+    except TypeError:
+        norm = colors.make_norm_from_scale(scale_cls)(
+            colors.Normalize)()
+    return type(norm)
+
+
+class ScalarMappable:
+    """
+    A mixin class to map scalar data to RGBA.
+
+    The ScalarMappable applies data normalization before returning RGBA colors
+    from the given colormap.
+    """
+
+    def __init__(self, norm=None, cmap=None):
+        """
+        Parameters
+        ----------
+        norm : `.Normalize` (or subclass thereof) or str or None
+            The normalizing object which scales data, typically into the
+            interval ``[0, 1]``.
+            If a `str`, a `.Normalize` subclass is dynamically generated based
+            on the scale with the corresponding name.
+            If *None*, *norm* defaults to a *colors.Normalize* object which
+            initializes its scaling based on the first data processed.
+        cmap : str or `~matplotlib.colors.Colormap`
+            The colormap used to map normalized data values to RGBA colors.
+        """
+        self._A = None
+        self._norm = None  # So that the setter knows we're initializing.
+        self.set_norm(norm)  # The Normalize instance of this ScalarMappable.
+        self.cmap = None  # So that the setter knows we're initializing.
+        self.set_cmap(cmap)  # The Colormap instance of this ScalarMappable.
+        #: The last colorbar associated with this ScalarMappable. May be None.
+        self.colorbar = None
+        self.callbacks = cbook.CallbackRegistry(signals=["changed"])
+
+    def _scale_norm(self, norm, vmin, vmax):
+        """
+        Helper for initial scaling.
+
+        Used by public functions that create a ScalarMappable and support
+        parameters *vmin*, *vmax* and *norm*. This makes sure that a *norm*
+        will take precedence over *vmin*, *vmax*.
+
+        Note that this method does not set the norm.
+        """
+        if vmin is not None or vmax is not None:
+            self.set_clim(vmin, vmax)
+            if isinstance(norm, colors.Normalize):
+                raise ValueError(
+                    "Passing a Normalize instance simultaneously with "
+                    "vmin/vmax is not supported.  Please pass vmin/vmax "
+                    "directly to the norm when creating it.")
+
+        # always resolve the autoscaling so we have concrete limits
+        # rather than deferring to draw time.
+        self.autoscale_None()
+
+    def to_rgba(self, x, alpha=None, bytes=False, norm=True):
+        """
+        Return a normalized RGBA array corresponding to *x*.
+
+        In the normal case, *x* is a 1D or 2D sequence of scalars, and
+        the corresponding `~numpy.ndarray` of RGBA values will be returned,
+        based on the norm and colormap set for this ScalarMappable.
+
+        There is one special case, for handling images that are already
+        RGB or RGBA, such as might have been read from an image file.
+        If *x* is an `~numpy.ndarray` with 3 dimensions,
+        and the last dimension is either 3 or 4, then it will be
+        treated as an RGB or RGBA array, and no mapping will be done.
+        The array can be `~numpy.uint8`, or it can be floats with
+        values in the 0-1 range; otherwise a ValueError will be raised.
+        Any NaNs or masked elements will be set to 0 alpha.
+        If the last dimension is 3, the *alpha* kwarg (defaulting to 1)
+        will be used to fill in the transparency.  If the last dimension
+        is 4, the *alpha* kwarg is ignored; it does not
+        replace the preexisting alpha.  A ValueError will be raised
+        if the third dimension is other than 3 or 4.
+
+        In either case, if *bytes* is *False* (default), the RGBA
+        array will be floats in the 0-1 range; if it is *True*,
+        the returned RGBA array will be `~numpy.uint8` in the 0 to 255 range.
+
+        If norm is False, no normalization of the input data is
+        performed, and it is assumed to be in the range (0-1).
+
+        """
+        # First check for special case, image input:
+        try:
+            if x.ndim == 3:
+                if x.shape[2] == 3:
+                    if alpha is None:
+                        alpha = 1
+                    if x.dtype == np.uint8:
+                        alpha = np.uint8(alpha * 255)
+                    m, n = x.shape[:2]
+                    xx = np.empty(shape=(m, n, 4), dtype=x.dtype)
+                    xx[:, :, :3] = x
+                    xx[:, :, 3] = alpha
+                elif x.shape[2] == 4:
+                    xx = x
+                else:
+                    raise ValueError("Third dimension must be 3 or 4")
+                if xx.dtype.kind == 'f':
+                    # If any of R, G, B, or A is nan, set to 0
+                    if np.any(nans := np.isnan(x)):
+                        if x.shape[2] == 4:
+                            xx = xx.copy()
+                        xx[np.any(nans, axis=2), :] = 0
+
+                    if norm and (xx.max() > 1 or xx.min() < 0):
+                        raise ValueError("Floating point image RGB values "
+                                         "must be in the 0..1 range.")
+                    if bytes:
+                        xx = (xx * 255).astype(np.uint8)
+                elif xx.dtype == np.uint8:
+                    if not bytes:
+                        xx = xx.astype(np.float32) / 255
+                else:
+                    raise ValueError("Image RGB array must be uint8 or "
+                                     "floating point; found %s" % xx.dtype)
+                # Account for any masked entries in the original array
+                # If any of R, G, B, or A are masked for an entry, we set alpha to 0
+                if np.ma.is_masked(x):
+                    xx[np.any(np.ma.getmaskarray(x), axis=2), 3] = 0
+                return xx
+        except AttributeError:
+            # e.g., x is not an ndarray; so try mapping it
+            pass
+
+        # This is the normal case, mapping a scalar array:
+        x = ma.asarray(x)
+        if norm:
+            x = self.norm(x)
+        rgba = self.cmap(x, alpha=alpha, bytes=bytes)
+        return rgba
+
+    def set_array(self, A):
+        """
+        Set the value array from array-like *A*.
+
+        Parameters
+        ----------
+        A : array-like or None
+            The values that are mapped to colors.
+
+            The base class `.ScalarMappable` does not make any assumptions on
+            the dimensionality and shape of the value array *A*.
+        """
+        if A is None:
+            self._A = None
+            return
+
+        A = cbook.safe_masked_invalid(A, copy=True)
+        if not np.can_cast(A.dtype, float, "same_kind"):
+            raise TypeError(f"Image data of dtype {A.dtype} cannot be "
+                            "converted to float")
+
+        self._A = A
+        if not self.norm.scaled():
+            self.norm.autoscale_None(A)
+
+    def get_array(self):
+        """
+        Return the array of values, that are mapped to colors.
+
+        The base class `.ScalarMappable` does not make any assumptions on
+        the dimensionality and shape of the array.
+        """
+        return self._A
+
+    def get_cmap(self):
+        """Return the `.Colormap` instance."""
+        return self.cmap
+
+    def get_clim(self):
+        """
+        Return the values (min, max) that are mapped to the colormap limits.
+        """
+        return self.norm.vmin, self.norm.vmax
+
+    def set_clim(self, vmin=None, vmax=None):
+        """
+        Set the norm limits for image scaling.
+
+        Parameters
+        ----------
+        vmin, vmax : float
+             The limits.
+
+             The limits may also be passed as a tuple (*vmin*, *vmax*) as a
+             single positional argument.
+
+             .. ACCEPTS: (vmin: float, vmax: float)
+        """
+        # If the norm's limits are updated self.changed() will be called
+        # through the callbacks attached to the norm
+        if vmax is None:
+            try:
+                vmin, vmax = vmin
+            except (TypeError, ValueError):
+                pass
+        if vmin is not None:
+            self.norm.vmin = colors._sanitize_extrema(vmin)
+        if vmax is not None:
+            self.norm.vmax = colors._sanitize_extrema(vmax)
+
+    def get_alpha(self):
+        """
+        Returns
+        -------
+        float
+            Always returns 1.
+        """
+        # This method is intended to be overridden by Artist sub-classes
+        return 1.
+
+    def set_cmap(self, cmap):
+        """
+        Set the colormap for luminance data.
+
+        Parameters
+        ----------
+        cmap : `.Colormap` or str or None
+        """
+        in_init = self.cmap is None
+
+        self.cmap = _ensure_cmap(cmap)
+        if not in_init:
+            self.changed()  # Things are not set up properly yet.
+
+    @property
+    def norm(self):
+        return self._norm
+
+    @norm.setter
+    def norm(self, norm):
+        _api.check_isinstance((colors.Normalize, str, None), norm=norm)
+        if norm is None:
+            norm = colors.Normalize()
+        elif isinstance(norm, str):
+            try:
+                scale_cls = scale._scale_mapping[norm]
+            except KeyError:
+                raise ValueError(
+                    "Invalid norm str name; the following values are "
+                    f"supported: {', '.join(scale._scale_mapping)}"
+                ) from None
+            norm = _auto_norm_from_scale(scale_cls)()
+
+        if norm is self.norm:
+            # We aren't updating anything
+            return
+
+        in_init = self.norm is None
+        # Remove the current callback and connect to the new one
+        if not in_init:
+            self.norm.callbacks.disconnect(self._id_norm)
+        self._norm = norm
+        self._id_norm = self.norm.callbacks.connect('changed',
+                                                    self.changed)
+        if not in_init:
+            self.changed()
+
+    def set_norm(self, norm):
+        """
+        Set the normalization instance.
+
+        Parameters
+        ----------
+        norm : `.Normalize` or str or None
+
+        Notes
+        -----
+        If there are any colorbars using the mappable for this norm, setting
+        the norm of the mappable will reset the norm, locator, and formatters
+        on the colorbar to default.
+        """
+        self.norm = norm
+
+    def autoscale(self):
+        """
+        Autoscale the scalar limits on the norm instance using the
+        current array
+        """
+        if self._A is None:
+            raise TypeError('You must first set_array for mappable')
+        # If the norm's limits are updated self.changed() will be called
+        # through the callbacks attached to the norm
+        self.norm.autoscale(self._A)
+
+    def autoscale_None(self):
+        """
+        Autoscale the scalar limits on the norm instance using the
+        current array, changing only limits that are None
+        """
+        if self._A is None:
+            raise TypeError('You must first set_array for mappable')
+        # If the norm's limits are updated self.changed() will be called
+        # through the callbacks attached to the norm
+        self.norm.autoscale_None(self._A)
+
+    def changed(self):
+        """
+        Call this whenever the mappable is changed to notify all the
+        callbackSM listeners to the 'changed' signal.
+        """
+        self.callbacks.process('changed', self)
+        self.stale = True
+
+
+# The docstrings here must be generic enough to apply to all relevant methods.
+mpl._docstring.interpd.update(
+    cmap_doc="""\
+cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
+    The Colormap instance or registered colormap name used to map scalar data
+    to colors.""",
+    norm_doc="""\
+norm : str or `~matplotlib.colors.Normalize`, optional
+    The normalization method used to scale scalar data to the [0, 1] range
+    before mapping to colors using *cmap*. By default, a linear scaling is
+    used, mapping the lowest value to 0 and the highest to 1.
+
+    If given, this can be one of the following:
+
+    - An instance of `.Normalize` or one of its subclasses
+      (see :ref:`colormapnorms`).
+    - A scale name, i.e. one of "linear", "log", "symlog", "logit", etc.  For a
+      list of available scales, call `matplotlib.scale.get_scale_names()`.
+      In that case, a suitable `.Normalize` subclass is dynamically generated
+      and instantiated.""",
+    vmin_vmax_doc="""\
+vmin, vmax : float, optional
+    When using scalar data and no explicit *norm*, *vmin* and *vmax* define
+    the data range that the colormap covers. By default, the colormap covers
+    the complete value range of the supplied data. It is an error to use
+    *vmin*/*vmax* when a *norm* instance is given (but using a `str` *norm*
+    name together with *vmin*/*vmax* is acceptable).""",
+)
+
+
+def _ensure_cmap(cmap):
+    """
+    Ensure that we have a `.Colormap` object.
+
+    For internal use to preserve type stability of errors.
+
+    Parameters
+    ----------
+    cmap : None, str, Colormap
+
+        - if a `Colormap`, return it
+        - if a string, look it up in mpl.colormaps
+        - if None, look up the default color map in mpl.colormaps
+
+    Returns
+    -------
+    Colormap
+
+    """
+    if isinstance(cmap, colors.Colormap):
+        return cmap
+    cmap_name = cmap if cmap is not None else mpl.rcParams["image.cmap"]
+    # use check_in_list to ensure type stability of the exception raised by
+    # the internal usage of this (ValueError vs KeyError)
+    if cmap_name not in _colormaps:
+        _api.check_in_list(sorted(_colormaps), cmap=cmap_name)
+    return mpl.colormaps[cmap_name]

llava_next/lib/python3.10/site-packages/matplotlib/collections.pyi

@@ -0,0 +1,236 @@
+from collections.abc import Callable, Iterable, Sequence
+from typing import Literal
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+from . import artist, cm, transforms
+from .backend_bases import MouseEvent
+from .artist import Artist
+from .colors import Normalize, Colormap
+from .lines import Line2D
+from .path import Path
+from .patches import Patch
+from .ticker import Locator, Formatter
+from .tri import Triangulation
+from .typing import ColorType, LineStyleType, CapStyleType, JoinStyleType
+
+class Collection(artist.Artist, cm.ScalarMappable):
+    def __init__(
+        self,
+        *,
+        edgecolors: ColorType | Sequence[ColorType] | None = ...,
+        facecolors: ColorType | Sequence[ColorType] | None = ...,
+        linewidths: float | Sequence[float] | None = ...,
+        linestyles: LineStyleType | Sequence[LineStyleType] = ...,
+        capstyle: CapStyleType | None = ...,
+        joinstyle: JoinStyleType | None = ...,
+        antialiaseds: bool | Sequence[bool] | None = ...,
+        offsets: tuple[float, float] | Sequence[tuple[float, float]] | None = ...,
+        offset_transform: transforms.Transform | None = ...,
+        norm: Normalize | None = ...,
+        cmap: Colormap | None = ...,
+        pickradius: float = ...,
+        hatch: str | None = ...,
+        urls: Sequence[str] | None = ...,
+        zorder: float = ...,
+        **kwargs
+    ) -> None: ...
+    def get_paths(self) -> Sequence[Path]: ...
+    def set_paths(self, paths: Sequence[Path]) -> None: ...
+    def get_transforms(self) -> Sequence[transforms.Transform]: ...
+    def get_offset_transform(self) -> transforms.Transform: ...
+    def set_offset_transform(self, offset_transform: transforms.Transform) -> None: ...
+    def get_datalim(self, transData: transforms.Transform) -> transforms.Bbox: ...
+    def set_pickradius(self, pickradius: float) -> None: ...
+    def get_pickradius(self) -> float: ...
+    def set_urls(self, urls: Sequence[str | None]) -> None: ...
+    def get_urls(self) -> Sequence[str | None]: ...
+    def set_hatch(self, hatch: str) -> None: ...
+    def get_hatch(self) -> str: ...
+    def set_offsets(self, offsets: ArrayLike) -> None: ...
+    def get_offsets(self) -> ArrayLike: ...
+    def set_linewidth(self, lw: float | Sequence[float]) -> None: ...
+    def set_linestyle(self, ls: LineStyleType | Sequence[LineStyleType]) -> None: ...
+    def set_capstyle(self, cs: CapStyleType) -> None: ...
+    def get_capstyle(self) -> Literal["butt", "projecting", "round"] | None: ...
+    def set_joinstyle(self, js: JoinStyleType) -> None: ...
+    def get_joinstyle(self) -> Literal["miter", "round", "bevel"] | None: ...
+    def set_antialiased(self, aa: bool | Sequence[bool]) -> None: ...
+    def get_antialiased(self) -> NDArray[np.bool_]: ...
+    def set_color(self, c: ColorType | Sequence[ColorType]) -> None: ...
+    def set_facecolor(self, c: ColorType | Sequence[ColorType]) -> None: ...
+    def get_facecolor(self) -> ColorType | Sequence[ColorType]: ...
+    def get_edgecolor(self) -> ColorType | Sequence[ColorType]: ...
+    def set_edgecolor(self, c: ColorType | Sequence[ColorType]) -> None: ...
+    def set_alpha(self, alpha: float | Sequence[float] | None) -> None: ...
+    def get_linewidth(self) -> float | Sequence[float]: ...
+    def get_linestyle(self) -> LineStyleType | Sequence[LineStyleType]: ...
+    def update_scalarmappable(self) -> None: ...
+    def get_fill(self) -> bool: ...
+    def update_from(self, other: Artist) -> None: ...
+
+class _CollectionWithSizes(Collection):
+    def get_sizes(self) -> np.ndarray: ...
+    def set_sizes(self, sizes: ArrayLike | None, dpi: float = ...) -> None: ...
+
+class PathCollection(_CollectionWithSizes):
+    def __init__(
+        self, paths: Sequence[Path], sizes: ArrayLike | None = ..., **kwargs
+    ) -> None: ...
+    def set_paths(self, paths: Sequence[Path]) -> None: ...
+    def get_paths(self) -> Sequence[Path]: ...
+    def legend_elements(
+        self,
+        prop: Literal["colors", "sizes"] = ...,
+        num: int | Literal["auto"] | ArrayLike | Locator = ...,
+        fmt: str | Formatter | None = ...,
+        func: Callable[[ArrayLike], ArrayLike] = ...,
+        **kwargs,
+    ) -> tuple[list[Line2D], list[str]]: ...
+
+class PolyCollection(_CollectionWithSizes):
+    def __init__(
+        self,
+        verts: Sequence[ArrayLike],
+        sizes: ArrayLike | None = ...,
+        *,
+        closed: bool = ...,
+        **kwargs
+    ) -> None: ...
+    def set_verts(
+        self, verts: Sequence[ArrayLike | Path], closed: bool = ...
+    ) -> None: ...
+    def set_paths(self, verts: Sequence[Path], closed: bool = ...) -> None: ...
+    def set_verts_and_codes(
+        self, verts: Sequence[ArrayLike | Path], codes: Sequence[int]
+    ) -> None: ...
+
+class RegularPolyCollection(_CollectionWithSizes):
+    def __init__(
+        self, numsides: int, *, rotation: float = ..., sizes: ArrayLike = ..., **kwargs
+    ) -> None: ...
+    def get_numsides(self) -> int: ...
+    def get_rotation(self) -> float: ...
+
+class StarPolygonCollection(RegularPolyCollection): ...
+class AsteriskPolygonCollection(RegularPolyCollection): ...
+
+class LineCollection(Collection):
+    def __init__(
+        self, segments: Sequence[ArrayLike], *, zorder: float = ..., **kwargs
+    ) -> None: ...
+    def set_segments(self, segments: Sequence[ArrayLike] | None) -> None: ...
+    def set_verts(self, segments: Sequence[ArrayLike] | None) -> None: ...
+    def set_paths(self, segments: Sequence[ArrayLike] | None) -> None: ...  # type: ignore[override]
+    def get_segments(self) -> list[np.ndarray]: ...
+    def set_color(self, c: ColorType | Sequence[ColorType]) -> None: ...
+    def set_colors(self, c: ColorType | Sequence[ColorType]) -> None: ...
+    def set_gapcolor(self, gapcolor: ColorType | Sequence[ColorType] | None) -> None: ...
+    def get_color(self) -> ColorType | Sequence[ColorType]: ...
+    def get_colors(self) -> ColorType | Sequence[ColorType]: ...
+    def get_gapcolor(self) -> ColorType | Sequence[ColorType] | None: ...
+
+
+class EventCollection(LineCollection):
+    def __init__(
+        self,
+        positions: ArrayLike,
+        orientation: Literal["horizontal", "vertical"] = ...,
+        *,
+        lineoffset: float = ...,
+        linelength: float = ...,
+        linewidth: float | Sequence[float] | None = ...,
+        color: ColorType | Sequence[ColorType] | None = ...,
+        linestyle: LineStyleType | Sequence[LineStyleType] = ...,
+        antialiased: bool | Sequence[bool] | None = ...,
+        **kwargs
+    ) -> None: ...
+    def get_positions(self) -> list[float]: ...
+    def set_positions(self, positions: Sequence[float] | None) -> None: ...
+    def add_positions(self, position: Sequence[float] | None) -> None: ...
+    def extend_positions(self, position: Sequence[float] | None) -> None: ...
+    def append_positions(self, position: Sequence[float] | None) -> None: ...
+    def is_horizontal(self) -> bool: ...
+    def get_orientation(self) -> Literal["horizontal", "vertical"]: ...
+    def switch_orientation(self) -> None: ...
+    def set_orientation(
+        self, orientation: Literal["horizontal", "vertical"]
+    ) -> None: ...
+    def get_linelength(self) -> float | Sequence[float]: ...
+    def set_linelength(self, linelength: float | Sequence[float]) -> None: ...
+    def get_lineoffset(self) -> float: ...
+    def set_lineoffset(self, lineoffset: float) -> None: ...
+    def get_linewidth(self) -> float: ...
+    def get_linewidths(self) -> Sequence[float]: ...
+    def get_color(self) -> ColorType: ...
+
+class CircleCollection(_CollectionWithSizes):
+    def __init__(self, sizes: float | ArrayLike, **kwargs) -> None: ...
+
+class EllipseCollection(Collection):
+    def __init__(
+        self,
+        widths: ArrayLike,
+        heights: ArrayLike,
+        angles: ArrayLike,
+        *,
+        units: Literal[
+            "points", "inches", "dots", "width", "height", "x", "y", "xy"
+        ] = ...,
+        **kwargs
+    ) -> None: ...
+    def set_widths(self, widths: ArrayLike) -> None: ...
+    def set_heights(self, heights: ArrayLike) -> None: ...
+    def set_angles(self, angles: ArrayLike) -> None: ...
+    def get_widths(self) -> ArrayLike: ...
+    def get_heights(self) -> ArrayLike: ...
+    def get_angles(self) -> ArrayLike: ...
+
+class PatchCollection(Collection):
+    def __init__(
+        self, patches: Iterable[Patch], *, match_original: bool = ..., **kwargs
+    ) -> None: ...
+    def set_paths(self, patches: Iterable[Patch]) -> None: ...  # type: ignore[override]
+
+class TriMesh(Collection):
+    def __init__(self, triangulation: Triangulation, **kwargs) -> None: ...
+    def get_paths(self) -> list[Path]: ...
+    # Parent class has an argument, perhaps add a noop arg?
+    def set_paths(self) -> None: ...  # type: ignore[override]
+    @staticmethod
+    def convert_mesh_to_paths(tri: Triangulation) -> list[Path]: ...
+
+class _MeshData:
+    def __init__(
+        self,
+        coordinates: ArrayLike,
+        *,
+        shading: Literal["flat", "gouraud"] = ...,
+    ) -> None: ...
+    def set_array(self, A: ArrayLike | None) -> None: ...
+    def get_coordinates(self) -> ArrayLike: ...
+    def get_facecolor(self) -> ColorType | Sequence[ColorType]: ...
+    def get_edgecolor(self) -> ColorType | Sequence[ColorType]: ...
+
+class QuadMesh(_MeshData, Collection):
+    def __init__(
+        self,
+        coordinates: ArrayLike,
+        *,
+        antialiased: bool = ...,
+        shading: Literal["flat", "gouraud"] = ...,
+        **kwargs
+    ) -> None: ...
+    def get_paths(self) -> list[Path]: ...
+    # Parent class has an argument, perhaps add a noop arg?
+    def set_paths(self) -> None: ...  # type: ignore[override]
+    def get_datalim(self, transData: transforms.Transform) -> transforms.Bbox: ...
+    def get_cursor_data(self, event: MouseEvent) -> float: ...
+
+class PolyQuadMesh(_MeshData, PolyCollection):
+    def __init__(
+        self,
+        coordinates: ArrayLike,
+        **kwargs
+    ) -> None: ...

llava_next/lib/python3.10/site-packages/matplotlib/colorbar.py

@@ -0,0 +1,1559 @@
+"""
+Colorbars are a visualization of the mapping from scalar values to colors.
+In Matplotlib they are drawn into a dedicated `~.axes.Axes`.
+
+.. note::
+   Colorbars are typically created through `.Figure.colorbar` or its pyplot
+   wrapper `.pyplot.colorbar`, which internally use `.Colorbar` together with
+   `.make_axes_gridspec` (for `.GridSpec`-positioned Axes) or `.make_axes` (for
+   non-`.GridSpec`-positioned Axes).
+
+   End-users most likely won't need to directly use this module's API.
+"""
+
+import logging
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib import _api, cbook, collections, cm, colors, contour, ticker
+import matplotlib.artist as martist
+import matplotlib.patches as mpatches
+import matplotlib.path as mpath
+import matplotlib.spines as mspines
+import matplotlib.transforms as mtransforms
+from matplotlib import _docstring
+
+_log = logging.getLogger(__name__)
+
+_docstring.interpd.update(
+    _make_axes_kw_doc="""
+location : None or {'left', 'right', 'top', 'bottom'}
+    The location, relative to the parent Axes, where the colorbar Axes
+    is created.  It also determines the *orientation* of the colorbar
+    (colorbars on the left and right are vertical, colorbars at the top
+    and bottom are horizontal).  If None, the location will come from the
+    *orientation* if it is set (vertical colorbars on the right, horizontal
+    ones at the bottom), or default to 'right' if *orientation* is unset.
+
+orientation : None or {'vertical', 'horizontal'}
+    The orientation of the colorbar.  It is preferable to set the *location*
+    of the colorbar, as that also determines the *orientation*; passing
+    incompatible values for *location* and *orientation* raises an exception.
+
+fraction : float, default: 0.15
+    Fraction of original Axes to use for colorbar.
+
+shrink : float, default: 1.0
+    Fraction by which to multiply the size of the colorbar.
+
+aspect : float, default: 20
+    Ratio of long to short dimensions.
+
+pad : float, default: 0.05 if vertical, 0.15 if horizontal
+    Fraction of original Axes between colorbar and new image Axes.
+
+anchor : (float, float), optional
+    The anchor point of the colorbar Axes.
+    Defaults to (0.0, 0.5) if vertical; (0.5, 1.0) if horizontal.
+
+panchor : (float, float), or *False*, optional
+    The anchor point of the colorbar parent Axes. If *False*, the parent
+    axes' anchor will be unchanged.
+    Defaults to (1.0, 0.5) if vertical; (0.5, 0.0) if horizontal.""",
+    _colormap_kw_doc="""
+extend : {'neither', 'both', 'min', 'max'}
+    Make pointed end(s) for out-of-range values (unless 'neither').  These are
+    set for a given colormap using the colormap set_under and set_over methods.
+
+extendfrac : {*None*, 'auto', length, lengths}
+    If set to *None*, both the minimum and maximum triangular colorbar
+    extensions will have a length of 5% of the interior colorbar length (this
+    is the default setting).
+
+    If set to 'auto', makes the triangular colorbar extensions the same lengths
+    as the interior boxes (when *spacing* is set to 'uniform') or the same
+    lengths as the respective adjacent interior boxes (when *spacing* is set to
+    'proportional').
+
+    If a scalar, indicates the length of both the minimum and maximum
+    triangular colorbar extensions as a fraction of the interior colorbar
+    length.  A two-element sequence of fractions may also be given, indicating
+    the lengths of the minimum and maximum colorbar extensions respectively as
+    a fraction of the interior colorbar length.
+
+extendrect : bool
+    If *False* the minimum and maximum colorbar extensions will be triangular
+    (the default).  If *True* the extensions will be rectangular.
+
+spacing : {'uniform', 'proportional'}
+    For discrete colorbars (`.BoundaryNorm` or contours), 'uniform' gives each
+    color the same space; 'proportional' makes the space proportional to the
+    data interval.
+
+ticks : None or list of ticks or Locator
+    If None, ticks are determined automatically from the input.
+
+format : None or str or Formatter
+    If None, `~.ticker.ScalarFormatter` is used.
+    Format strings, e.g., ``"%4.2e"`` or ``"{x:.2e}"``, are supported.
+    An alternative `~.ticker.Formatter` may be given instead.
+
+drawedges : bool
+    Whether to draw lines at color boundaries.
+
+label : str
+    The label on the colorbar's long axis.
+
+boundaries, values : None or a sequence
+    If unset, the colormap will be displayed on a 0-1 scale.
+    If sequences, *values* must have a length 1 less than *boundaries*.  For
+    each region delimited by adjacent entries in *boundaries*, the color mapped
+    to the corresponding value in values will be used.
+    Normally only useful for indexed colors (i.e. ``norm=NoNorm()``) or other
+    unusual circumstances.""")
+
+
+def _set_ticks_on_axis_warn(*args, **kwargs):
+    # a top level function which gets put in at the axes'
+    # set_xticks and set_yticks by Colorbar.__init__.
+    _api.warn_external("Use the colorbar set_ticks() method instead.")
+
+
+class _ColorbarSpine(mspines.Spine):
+    def __init__(self, axes):
+        self._ax = axes
+        super().__init__(axes, 'colorbar', mpath.Path(np.empty((0, 2))))
+        mpatches.Patch.set_transform(self, axes.transAxes)
+
+    def get_window_extent(self, renderer=None):
+        # This Spine has no Axis associated with it, and doesn't need to adjust
+        # its location, so we can directly get the window extent from the
+        # super-super-class.
+        return mpatches.Patch.get_window_extent(self, renderer=renderer)
+
+    def set_xy(self, xy):
+        self._path = mpath.Path(xy, closed=True)
+        self._xy = xy
+        self.stale = True
+
+    def draw(self, renderer):
+        ret = mpatches.Patch.draw(self, renderer)
+        self.stale = False
+        return ret
+
+
+class _ColorbarAxesLocator:
+    """
+    Shrink the Axes if there are triangular or rectangular extends.
+    """
+    def __init__(self, cbar):
+        self._cbar = cbar
+        self._orig_locator = cbar.ax._axes_locator
+
+    def __call__(self, ax, renderer):
+        if self._orig_locator is not None:
+            pos = self._orig_locator(ax, renderer)
+        else:
+            pos = ax.get_position(original=True)
+        if self._cbar.extend == 'neither':
+            return pos
+
+        y, extendlen = self._cbar._proportional_y()
+        if not self._cbar._extend_lower():
+            extendlen[0] = 0
+        if not self._cbar._extend_upper():
+            extendlen[1] = 0
+        len = sum(extendlen) + 1
+        shrink = 1 / len
+        offset = extendlen[0] / len
+        # we need to reset the aspect ratio of the axes to account
+        # of the extends...
+        if hasattr(ax, '_colorbar_info'):
+            aspect = ax._colorbar_info['aspect']
+        else:
+            aspect = False
+        # now shrink and/or offset to take into account the
+        # extend tri/rectangles.
+        if self._cbar.orientation == 'vertical':
+            if aspect:
+                self._cbar.ax.set_box_aspect(aspect*shrink)
+            pos = pos.shrunk(1, shrink).translated(0, offset * pos.height)
+        else:
+            if aspect:
+                self._cbar.ax.set_box_aspect(1/(aspect * shrink))
+            pos = pos.shrunk(shrink, 1).translated(offset * pos.width, 0)
+        return pos
+
+    def get_subplotspec(self):
+        # make tight_layout happy..
+        return (
+            self._cbar.ax.get_subplotspec()
+            or getattr(self._orig_locator, "get_subplotspec", lambda: None)())
+
+
+@_docstring.interpd
+class Colorbar:
+    r"""
+    Draw a colorbar in an existing Axes.
+
+    Typically, colorbars are created using `.Figure.colorbar` or
+    `.pyplot.colorbar` and associated with `.ScalarMappable`\s (such as an
+    `.AxesImage` generated via `~.axes.Axes.imshow`).
+
+    In order to draw a colorbar not associated with other elements in the
+    figure, e.g. when showing a colormap by itself, one can create an empty
+    `.ScalarMappable`, or directly pass *cmap* and *norm* instead of *mappable*
+    to `Colorbar`.
+
+    Useful public methods are :meth:`set_label` and :meth:`add_lines`.
+
+    Attributes
+    ----------
+    ax : `~matplotlib.axes.Axes`
+        The `~.axes.Axes` instance in which the colorbar is drawn.
+    lines : list
+        A list of `.LineCollection` (empty if no lines were drawn).
+    dividers : `.LineCollection`
+        A LineCollection (empty if *drawedges* is ``False``).
+
+    Parameters
+    ----------
+    ax : `~matplotlib.axes.Axes`
+        The `~.axes.Axes` instance in which the colorbar is drawn.
+
+    mappable : `.ScalarMappable`
+        The mappable whose colormap and norm will be used.
+
+        To show the under- and over- value colors, the mappable's norm should
+        be specified as ::
+
+            norm = colors.Normalize(clip=False)
+
+        To show the colors versus index instead of on a 0-1 scale, use::
+
+            norm=colors.NoNorm()
+
+    cmap : `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
+        The colormap to use.  This parameter is ignored, unless *mappable* is
+        None.
+
+    norm : `~matplotlib.colors.Normalize`
+        The normalization to use.  This parameter is ignored, unless *mappable*
+        is None.
+
+    alpha : float
+        The colorbar transparency between 0 (transparent) and 1 (opaque).
+
+    orientation : None or {'vertical', 'horizontal'}
+        If None, use the value determined by *location*. If both
+        *orientation* and *location* are None then defaults to 'vertical'.
+
+    ticklocation : {'auto', 'left', 'right', 'top', 'bottom'}
+        The location of the colorbar ticks. The *ticklocation* must match
+        *orientation*. For example, a horizontal colorbar can only have ticks
+        at the top or the bottom. If 'auto', the ticks will be the same as
+        *location*, so a colorbar to the left will have ticks to the left. If
+        *location* is None, the ticks will be at the bottom for a horizontal
+        colorbar and at the right for a vertical.
+
+    %(_colormap_kw_doc)s
+
+    location : None or {'left', 'right', 'top', 'bottom'}
+        Set the *orientation* and *ticklocation* of the colorbar using a
+        single argument. Colorbars on the left and right are vertical,
+        colorbars at the top and bottom are horizontal. The *ticklocation* is
+        the same as *location*, so if *location* is 'top', the ticks are on
+        the top. *orientation* and/or *ticklocation* can be provided as well
+        and overrides the value set by *location*, but there will be an error
+        for incompatible combinations.
+
+        .. versionadded:: 3.7
+    """
+
+    n_rasterize = 50  # rasterize solids if number of colors >= n_rasterize
+
+    def __init__(self, ax, mappable=None, *, cmap=None,
+                 norm=None,
+                 alpha=None,
+                 values=None,
+                 boundaries=None,
+                 orientation=None,
+                 ticklocation='auto',
+                 extend=None,
+                 spacing='uniform',  # uniform or proportional
+                 ticks=None,
+                 format=None,
+                 drawedges=False,
+                 extendfrac=None,
+                 extendrect=False,
+                 label='',
+                 location=None,
+                 ):
+
+        if mappable is None:
+            mappable = cm.ScalarMappable(norm=norm, cmap=cmap)
+
+        self.mappable = mappable
+        cmap = mappable.cmap
+        norm = mappable.norm
+
+        filled = True
+        if isinstance(mappable, contour.ContourSet):
+            cs = mappable
+            alpha = cs.get_alpha()
+            boundaries = cs._levels
+            values = cs.cvalues
+            extend = cs.extend
+            filled = cs.filled
+            if ticks is None:
+                ticks = ticker.FixedLocator(cs.levels, nbins=10)
+        elif isinstance(mappable, martist.Artist):
+            alpha = mappable.get_alpha()
+
+        mappable.colorbar = self
+        mappable.colorbar_cid = mappable.callbacks.connect(
+            'changed', self.update_normal)
+
+        location_orientation = _get_orientation_from_location(location)
+
+        _api.check_in_list(
+            [None, 'vertical', 'horizontal'], orientation=orientation)
+        _api.check_in_list(
+            ['auto', 'left', 'right', 'top', 'bottom'],
+            ticklocation=ticklocation)
+        _api.check_in_list(
+            ['uniform', 'proportional'], spacing=spacing)
+
+        if location_orientation is not None and orientation is not None:
+            if location_orientation != orientation:
+                raise TypeError(
+                    "location and orientation are mutually exclusive")
+        else:
+            orientation = orientation or location_orientation or "vertical"
+
+        self.ax = ax
+        self.ax._axes_locator = _ColorbarAxesLocator(self)
+
+        if extend is None:
+            if (not isinstance(mappable, contour.ContourSet)
+                    and getattr(cmap, 'colorbar_extend', False) is not False):
+                extend = cmap.colorbar_extend
+            elif hasattr(norm, 'extend'):
+                extend = norm.extend
+            else:
+                extend = 'neither'
+        self.alpha = None
+        # Call set_alpha to handle array-like alphas properly
+        self.set_alpha(alpha)
+        self.cmap = cmap
+        self.norm = norm
+        self.values = values
+        self.boundaries = boundaries
+        self.extend = extend
+        self._inside = _api.check_getitem(
+            {'neither': slice(0, None), 'both': slice(1, -1),
+             'min': slice(1, None), 'max': slice(0, -1)},
+            extend=extend)
+        self.spacing = spacing
+        self.orientation = orientation
+        self.drawedges = drawedges
+        self._filled = filled
+        self.extendfrac = extendfrac
+        self.extendrect = extendrect
+        self._extend_patches = []
+        self.solids = None
+        self.solids_patches = []
+        self.lines = []
+
+        for spine in self.ax.spines.values():
+            spine.set_visible(False)
+        self.outline = self.ax.spines['outline'] = _ColorbarSpine(self.ax)
+
+        self.dividers = collections.LineCollection(
+            [],
+            colors=[mpl.rcParams['axes.edgecolor']],
+            linewidths=[0.5 * mpl.rcParams['axes.linewidth']],
+            clip_on=False)
+        self.ax.add_collection(self.dividers)
+
+        self._locator = None
+        self._minorlocator = None
+        self._formatter = None
+        self._minorformatter = None
+
+        if ticklocation == 'auto':
+            ticklocation = _get_ticklocation_from_orientation(
+                orientation) if location is None else location
+        self.ticklocation = ticklocation
+
+        self.set_label(label)
+        self._reset_locator_formatter_scale()
+
+        if np.iterable(ticks):
+            self._locator = ticker.FixedLocator(ticks, nbins=len(ticks))
+        else:
+            self._locator = ticks
+
+        if isinstance(format, str):
+            # Check format between FormatStrFormatter and StrMethodFormatter
+            try:
+                self._formatter = ticker.FormatStrFormatter(format)
+                _ = self._formatter(0)
+            except (TypeError, ValueError):
+                self._formatter = ticker.StrMethodFormatter(format)
+        else:
+            self._formatter = format  # Assume it is a Formatter or None
+        self._draw_all()
+
+        if isinstance(mappable, contour.ContourSet) and not mappable.filled:
+            self.add_lines(mappable)
+
+        # Link the Axes and Colorbar for interactive use
+        self.ax._colorbar = self
+        # Don't navigate on any of these types of mappables
+        if (isinstance(self.norm, (colors.BoundaryNorm, colors.NoNorm)) or
+                isinstance(self.mappable, contour.ContourSet)):
+            self.ax.set_navigate(False)
+
+        # These are the functions that set up interactivity on this colorbar
+        self._interactive_funcs = ["_get_view", "_set_view",
+                                   "_set_view_from_bbox", "drag_pan"]
+        for x in self._interactive_funcs:
+            setattr(self.ax, x, getattr(self, x))
+        # Set the cla function to the cbar's method to override it
+        self.ax.cla = self._cbar_cla
+        # Callbacks for the extend calculations to handle inverting the axis
+        self._extend_cid1 = self.ax.callbacks.connect(
+            "xlim_changed", self._do_extends)
+        self._extend_cid2 = self.ax.callbacks.connect(
+            "ylim_changed", self._do_extends)
+
+    @property
+    def locator(self):
+        """Major tick `.Locator` for the colorbar."""
+        return self._long_axis().get_major_locator()
+
+    @locator.setter
+    def locator(self, loc):
+        self._long_axis().set_major_locator(loc)
+        self._locator = loc
+
+    @property
+    def minorlocator(self):
+        """Minor tick `.Locator` for the colorbar."""
+        return self._long_axis().get_minor_locator()
+
+    @minorlocator.setter
+    def minorlocator(self, loc):
+        self._long_axis().set_minor_locator(loc)
+        self._minorlocator = loc
+
+    @property
+    def formatter(self):
+        """Major tick label `.Formatter` for the colorbar."""
+        return self._long_axis().get_major_formatter()
+
+    @formatter.setter
+    def formatter(self, fmt):
+        self._long_axis().set_major_formatter(fmt)
+        self._formatter = fmt
+
+    @property
+    def minorformatter(self):
+        """Minor tick `.Formatter` for the colorbar."""
+        return self._long_axis().get_minor_formatter()
+
+    @minorformatter.setter
+    def minorformatter(self, fmt):
+        self._long_axis().set_minor_formatter(fmt)
+        self._minorformatter = fmt
+
+    def _cbar_cla(self):
+        """Function to clear the interactive colorbar state."""
+        for x in self._interactive_funcs:
+            delattr(self.ax, x)
+        # We now restore the old cla() back and can call it directly
+        del self.ax.cla
+        self.ax.cla()
+
+    def update_normal(self, mappable):
+        """
+        Update solid patches, lines, etc.
+
+        This is meant to be called when the norm of the image or contour plot
+        to which this colorbar belongs changes.
+
+        If the norm on the mappable is different than before, this resets the
+        locator and formatter for the axis, so if these have been customized,
+        they will need to be customized again.  However, if the norm only
+        changes values of *vmin*, *vmax* or *cmap* then the old formatter
+        and locator will be preserved.
+        """
+        _log.debug('colorbar update normal %r %r', mappable.norm, self.norm)
+        self.mappable = mappable
+        self.set_alpha(mappable.get_alpha())
+        self.cmap = mappable.cmap
+        if mappable.norm != self.norm:
+            self.norm = mappable.norm
+            self._reset_locator_formatter_scale()
+
+        self._draw_all()
+        if isinstance(self.mappable, contour.ContourSet):
+            CS = self.mappable
+            if not CS.filled:
+                self.add_lines(CS)
+        self.stale = True
+
+    def _draw_all(self):
+        """
+        Calculate any free parameters based on the current cmap and norm,
+        and do all the drawing.
+        """
+        if self.orientation == 'vertical':
+            if mpl.rcParams['ytick.minor.visible']:
+                self.minorticks_on()
+        else:
+            if mpl.rcParams['xtick.minor.visible']:
+                self.minorticks_on()
+        self._long_axis().set(label_position=self.ticklocation,
+                              ticks_position=self.ticklocation)
+        self._short_axis().set_ticks([])
+        self._short_axis().set_ticks([], minor=True)
+
+        # Set self._boundaries and self._values, including extensions.
+        # self._boundaries are the edges of each square of color, and
+        # self._values are the value to map into the norm to get the
+        # color:
+        self._process_values()
+        # Set self.vmin and self.vmax to first and last boundary, excluding
+        # extensions:
+        self.vmin, self.vmax = self._boundaries[self._inside][[0, -1]]
+        # Compute the X/Y mesh.
+        X, Y = self._mesh()
+        # draw the extend triangles, and shrink the inner Axes to accommodate.
+        # also adds the outline path to self.outline spine:
+        self._do_extends()
+        lower, upper = self.vmin, self.vmax
+        if self._long_axis().get_inverted():
+            # If the axis is inverted, we need to swap the vmin/vmax
+            lower, upper = upper, lower
+        if self.orientation == 'vertical':
+            self.ax.set_xlim(0, 1)
+            self.ax.set_ylim(lower, upper)
+        else:
+            self.ax.set_ylim(0, 1)
+            self.ax.set_xlim(lower, upper)
+
+        # set up the tick locators and formatters.  A bit complicated because
+        # boundary norms + uniform spacing requires a manual locator.
+        self.update_ticks()
+
+        if self._filled:
+            ind = np.arange(len(self._values))
+            if self._extend_lower():
+                ind = ind[1:]
+            if self._extend_upper():
+                ind = ind[:-1]
+            self._add_solids(X, Y, self._values[ind, np.newaxis])
+
+    def _add_solids(self, X, Y, C):
+        """Draw the colors; optionally add separators."""
+        # Cleanup previously set artists.
+        if self.solids is not None:
+            self.solids.remove()
+        for solid in self.solids_patches:
+            solid.remove()
+        # Add new artist(s), based on mappable type.  Use individual patches if
+        # hatching is needed, pcolormesh otherwise.
+        mappable = getattr(self, 'mappable', None)
+        if (isinstance(mappable, contour.ContourSet)
+                and any(hatch is not None for hatch in mappable.hatches)):
+            self._add_solids_patches(X, Y, C, mappable)
+        else:
+            self.solids = self.ax.pcolormesh(
+                X, Y, C, cmap=self.cmap, norm=self.norm, alpha=self.alpha,
+                edgecolors='none', shading='flat')
+            if not self.drawedges:
+                if len(self._y) >= self.n_rasterize:
+                    self.solids.set_rasterized(True)
+        self._update_dividers()
+
+    def _update_dividers(self):
+        if not self.drawedges:
+            self.dividers.set_segments([])
+            return
+        # Place all *internal* dividers.
+        if self.orientation == 'vertical':
+            lims = self.ax.get_ylim()
+            bounds = (lims[0] < self._y) & (self._y < lims[1])
+        else:
+            lims = self.ax.get_xlim()
+            bounds = (lims[0] < self._y) & (self._y < lims[1])
+        y = self._y[bounds]
+        # And then add outer dividers if extensions are on.
+        if self._extend_lower():
+            y = np.insert(y, 0, lims[0])
+        if self._extend_upper():
+            y = np.append(y, lims[1])
+        X, Y = np.meshgrid([0, 1], y)
+        if self.orientation == 'vertical':
+            segments = np.dstack([X, Y])
+        else:
+            segments = np.dstack([Y, X])
+        self.dividers.set_segments(segments)
+
+    def _add_solids_patches(self, X, Y, C, mappable):
+        hatches = mappable.hatches * (len(C) + 1)  # Have enough hatches.
+        if self._extend_lower():
+            # remove first hatch that goes into the extend patch
+            hatches = hatches[1:]
+        patches = []
+        for i in range(len(X) - 1):
+            xy = np.array([[X[i, 0], Y[i, 1]],
+                           [X[i, 1], Y[i, 0]],
+                           [X[i + 1, 1], Y[i + 1, 0]],
+                           [X[i + 1, 0], Y[i + 1, 1]]])
+            patch = mpatches.PathPatch(mpath.Path(xy),
+                                       facecolor=self.cmap(self.norm(C[i][0])),
+                                       hatch=hatches[i], linewidth=0,
+                                       antialiased=False, alpha=self.alpha)
+            self.ax.add_patch(patch)
+            patches.append(patch)
+        self.solids_patches = patches
+
+    def _do_extends(self, ax=None):
+        """
+        Add the extend tri/rectangles on the outside of the Axes.
+
+        ax is unused, but required due to the callbacks on xlim/ylim changed
+        """
+        # Clean up any previous extend patches
+        for patch in self._extend_patches:
+            patch.remove()
+        self._extend_patches = []
+        # extend lengths are fraction of the *inner* part of colorbar,
+        # not the total colorbar:
+        _, extendlen = self._proportional_y()
+        bot = 0 - (extendlen[0] if self._extend_lower() else 0)
+        top = 1 + (extendlen[1] if self._extend_upper() else 0)
+
+        # xyout is the outline of the colorbar including the extend patches:
+        if not self.extendrect:
+            # triangle:
+            xyout = np.array([[0, 0], [0.5, bot], [1, 0],
+                              [1, 1], [0.5, top], [0, 1], [0, 0]])
+        else:
+            # rectangle:
+            xyout = np.array([[0, 0], [0, bot], [1, bot], [1, 0],
+                              [1, 1], [1, top], [0, top], [0, 1],
+                              [0, 0]])
+
+        if self.orientation == 'horizontal':
+            xyout = xyout[:, ::-1]
+
+        # xyout is the path for the spine:
+        self.outline.set_xy(xyout)
+        if not self._filled:
+            return
+
+        # Make extend triangles or rectangles filled patches.  These are
+        # defined in the outer parent axes' coordinates:
+        mappable = getattr(self, 'mappable', None)
+        if (isinstance(mappable, contour.ContourSet)
+                and any(hatch is not None for hatch in mappable.hatches)):
+            hatches = mappable.hatches * (len(self._y) + 1)
+        else:
+            hatches = [None] * (len(self._y) + 1)
+
+        if self._extend_lower():
+            if not self.extendrect:
+                # triangle
+                xy = np.array([[0, 0], [0.5, bot], [1, 0]])
+            else:
+                # rectangle
+                xy = np.array([[0, 0], [0, bot], [1., bot], [1, 0]])
+            if self.orientation == 'horizontal':
+                xy = xy[:, ::-1]
+            # add the patch
+            val = -1 if self._long_axis().get_inverted() else 0
+            color = self.cmap(self.norm(self._values[val]))
+            patch = mpatches.PathPatch(
+                mpath.Path(xy), facecolor=color, alpha=self.alpha,
+                linewidth=0, antialiased=False,
+                transform=self.ax.transAxes,
+                hatch=hatches[0], clip_on=False,
+                # Place it right behind the standard patches, which is
+                # needed if we updated the extends
+                zorder=np.nextafter(self.ax.patch.zorder, -np.inf))
+            self.ax.add_patch(patch)
+            self._extend_patches.append(patch)
+            # remove first hatch that goes into the extend patch
+            hatches = hatches[1:]
+        if self._extend_upper():
+            if not self.extendrect:
+                # triangle
+                xy = np.array([[0, 1], [0.5, top], [1, 1]])
+            else:
+                # rectangle
+                xy = np.array([[0, 1], [0, top], [1, top], [1, 1]])
+            if self.orientation == 'horizontal':
+                xy = xy[:, ::-1]
+            # add the patch
+            val = 0 if self._long_axis().get_inverted() else -1
+            color = self.cmap(self.norm(self._values[val]))
+            hatch_idx = len(self._y) - 1
+            patch = mpatches.PathPatch(
+                mpath.Path(xy), facecolor=color, alpha=self.alpha,
+                linewidth=0, antialiased=False,
+                transform=self.ax.transAxes, hatch=hatches[hatch_idx],
+                clip_on=False,
+                # Place it right behind the standard patches, which is
+                # needed if we updated the extends
+                zorder=np.nextafter(self.ax.patch.zorder, -np.inf))
+            self.ax.add_patch(patch)
+            self._extend_patches.append(patch)
+
+        self._update_dividers()
+
+    def add_lines(self, *args, **kwargs):
+        """
+        Draw lines on the colorbar.
+
+        The lines are appended to the list :attr:`lines`.
+
+        Parameters
+        ----------
+        levels : array-like
+            The positions of the lines.
+        colors : :mpltype:`color` or list of :mpltype:`color`
+            Either a single color applying to all lines or one color value for
+            each line.
+        linewidths : float or array-like
+            Either a single linewidth applying to all lines or one linewidth
+            for each line.
+        erase : bool, default: True
+            Whether to remove any previously added lines.
+
+        Notes
+        -----
+        Alternatively, this method can also be called with the signature
+        ``colorbar.add_lines(contour_set, erase=True)``, in which case
+        *levels*, *colors*, and *linewidths* are taken from *contour_set*.
+        """
+        params = _api.select_matching_signature(
+            [lambda self, CS, erase=True: locals(),
+             lambda self, levels, colors, linewidths, erase=True: locals()],
+            self, *args, **kwargs)
+        if "CS" in params:
+            self, cs, erase = params.values()
+            if not isinstance(cs, contour.ContourSet) or cs.filled:
+                raise ValueError("If a single artist is passed to add_lines, "
+                                 "it must be a ContourSet of lines")
+            # TODO: Make colorbar lines auto-follow changes in contour lines.
+            return self.add_lines(
+                cs.levels,
+                cs.to_rgba(cs.cvalues, cs.alpha),
+                cs.get_linewidths(),
+                erase=erase)
+        else:
+            self, levels, colors, linewidths, erase = params.values()
+
+        y = self._locate(levels)
+        rtol = (self._y[-1] - self._y[0]) * 1e-10
+        igood = (y < self._y[-1] + rtol) & (y > self._y[0] - rtol)
+        y = y[igood]
+        if np.iterable(colors):
+            colors = np.asarray(colors)[igood]
+        if np.iterable(linewidths):
+            linewidths = np.asarray(linewidths)[igood]
+        X, Y = np.meshgrid([0, 1], y)
+        if self.orientation == 'vertical':
+            xy = np.stack([X, Y], axis=-1)
+        else:
+            xy = np.stack([Y, X], axis=-1)
+        col = collections.LineCollection(xy, linewidths=linewidths,
+                                         colors=colors)
+
+        if erase and self.lines:
+            for lc in self.lines:
+                lc.remove()
+            self.lines = []
+        self.lines.append(col)
+
+        # make a clip path that is just a linewidth bigger than the Axes...
+        fac = np.max(linewidths) / 72
+        xy = np.array([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]])
+        inches = self.ax.get_figure().dpi_scale_trans
+        # do in inches:
+        xy = inches.inverted().transform(self.ax.transAxes.transform(xy))
+        xy[[0, 1, 4], 1] -= fac
+        xy[[2, 3], 1] += fac
+        # back to axes units...
+        xy = self.ax.transAxes.inverted().transform(inches.transform(xy))
+        col.set_clip_path(mpath.Path(xy, closed=True),
+                          self.ax.transAxes)
+        self.ax.add_collection(col)
+        self.stale = True
+
+    def update_ticks(self):
+        """
+        Set up the ticks and ticklabels. This should not be needed by users.
+        """
+        # Get the locator and formatter; defaults to self._locator if not None.
+        self._get_ticker_locator_formatter()
+        self._long_axis().set_major_locator(self._locator)
+        self._long_axis().set_minor_locator(self._minorlocator)
+        self._long_axis().set_major_formatter(self._formatter)
+
+    def _get_ticker_locator_formatter(self):
+        """
+        Return the ``locator`` and ``formatter`` of the colorbar.
+
+        If they have not been defined (i.e. are *None*), the formatter and
+        locator are retrieved from the axis, or from the value of the
+        boundaries for a boundary norm.
+
+        Called by update_ticks...
+        """
+        locator = self._locator
+        formatter = self._formatter
+        minorlocator = self._minorlocator
+        if isinstance(self.norm, colors.BoundaryNorm):
+            b = self.norm.boundaries
+            if locator is None:
+                locator = ticker.FixedLocator(b, nbins=10)
+            if minorlocator is None:
+                minorlocator = ticker.FixedLocator(b)
+        elif isinstance(self.norm, colors.NoNorm):
+            if locator is None:
+                # put ticks on integers between the boundaries of NoNorm
+                nv = len(self._values)
+                base = 1 + int(nv / 10)
+                locator = ticker.IndexLocator(base=base, offset=.5)
+        elif self.boundaries is not None:
+            b = self._boundaries[self._inside]
+            if locator is None:
+                locator = ticker.FixedLocator(b, nbins=10)
+        else:  # most cases:
+            if locator is None:
+                # we haven't set the locator explicitly, so use the default
+                # for this axis:
+                locator = self._long_axis().get_major_locator()
+            if minorlocator is None:
+                minorlocator = self._long_axis().get_minor_locator()
+
+        if minorlocator is None:
+            minorlocator = ticker.NullLocator()
+
+        if formatter is None:
+            formatter = self._long_axis().get_major_formatter()
+
+        self._locator = locator
+        self._formatter = formatter
+        self._minorlocator = minorlocator
+        _log.debug('locator: %r', locator)
+
+    def set_ticks(self, ticks, *, labels=None, minor=False, **kwargs):
+        """
+        Set tick locations.
+
+        Parameters
+        ----------
+        ticks : 1D array-like
+            List of tick locations.
+        labels : list of str, optional
+            List of tick labels. If not set, the labels show the data value.
+        minor : bool, default: False
+            If ``False``, set the major ticks; if ``True``, the minor ticks.
+        **kwargs
+            `.Text` properties for the labels. These take effect only if you
+            pass *labels*. In other cases, please use `~.Axes.tick_params`.
+        """
+        if np.iterable(ticks):
+            self._long_axis().set_ticks(ticks, labels=labels, minor=minor,
+                                        **kwargs)
+            self._locator = self._long_axis().get_major_locator()
+        else:
+            self._locator = ticks
+            self._long_axis().set_major_locator(self._locator)
+        self.stale = True
+
+    def get_ticks(self, minor=False):
+        """
+        Return the ticks as a list of locations.
+
+        Parameters
+        ----------
+        minor : boolean, default: False
+            if True return the minor ticks.
+        """
+        if minor:
+            return self._long_axis().get_minorticklocs()
+        else:
+            return self._long_axis().get_majorticklocs()
+
+    def set_ticklabels(self, ticklabels, *, minor=False, **kwargs):
+        """
+        [*Discouraged*] Set tick labels.
+
+        .. admonition:: Discouraged
+
+            The use of this method is discouraged, because of the dependency
+            on tick positions. In most cases, you'll want to use
+            ``set_ticks(positions, labels=labels)`` instead.
+
+            If you are using this method, you should always fix the tick
+            positions before, e.g. by using `.Colorbar.set_ticks` or by
+            explicitly setting a `~.ticker.FixedLocator` on the long axis
+            of the colorbar. Otherwise, ticks are free to move and the
+            labels may end up in unexpected positions.
+
+        Parameters
+        ----------
+        ticklabels : sequence of str or of `.Text`
+            Texts for labeling each tick location in the sequence set by
+            `.Colorbar.set_ticks`; the number of labels must match the number
+            of locations.
+
+        update_ticks : bool, default: True
+            This keyword argument is ignored and will be removed.
+            Deprecated
+
+        minor : bool
+            If True, set minor ticks instead of major ticks.
+
+        **kwargs
+            `.Text` properties for the labels.
+        """
+        self._long_axis().set_ticklabels(ticklabels, minor=minor, **kwargs)
+
+    def minorticks_on(self):
+        """
+        Turn on colorbar minor ticks.
+        """
+        self.ax.minorticks_on()
+        self._short_axis().set_minor_locator(ticker.NullLocator())
+
+    def minorticks_off(self):
+        """Turn the minor ticks of the colorbar off."""
+        self._minorlocator = ticker.NullLocator()
+        self._long_axis().set_minor_locator(self._minorlocator)
+
+    def set_label(self, label, *, loc=None, **kwargs):
+        """
+        Add a label to the long axis of the colorbar.
+
+        Parameters
+        ----------
+        label : str
+            The label text.
+        loc : str, optional
+            The location of the label.
+
+            - For horizontal orientation one of {'left', 'center', 'right'}
+            - For vertical orientation one of {'bottom', 'center', 'top'}
+
+            Defaults to :rc:`xaxis.labellocation` or :rc:`yaxis.labellocation`
+            depending on the orientation.
+        **kwargs
+            Keyword arguments are passed to `~.Axes.set_xlabel` /
+            `~.Axes.set_ylabel`.
+            Supported keywords are *labelpad* and `.Text` properties.
+        """
+        if self.orientation == "vertical":
+            self.ax.set_ylabel(label, loc=loc, **kwargs)
+        else:
+            self.ax.set_xlabel(label, loc=loc, **kwargs)
+        self.stale = True
+
+    def set_alpha(self, alpha):
+        """
+        Set the transparency between 0 (transparent) and 1 (opaque).
+
+        If an array is provided, *alpha* will be set to None to use the
+        transparency values associated with the colormap.
+        """
+        self.alpha = None if isinstance(alpha, np.ndarray) else alpha
+
+    def _set_scale(self, scale, **kwargs):
+        """
+        Set the colorbar long axis scale.
+
+        Parameters
+        ----------
+        scale : {"linear", "log", "symlog", "logit", ...} or `.ScaleBase`
+            The axis scale type to apply.
+
+        **kwargs
+            Different keyword arguments are accepted, depending on the scale.
+            See the respective class keyword arguments:
+
+            - `matplotlib.scale.LinearScale`
+            - `matplotlib.scale.LogScale`
+            - `matplotlib.scale.SymmetricalLogScale`
+            - `matplotlib.scale.LogitScale`
+            - `matplotlib.scale.FuncScale`
+            - `matplotlib.scale.AsinhScale`
+
+        Notes
+        -----
+        By default, Matplotlib supports the above-mentioned scales.
+        Additionally, custom scales may be registered using
+        `matplotlib.scale.register_scale`. These scales can then also
+        be used here.
+        """
+        self._long_axis()._set_axes_scale(scale, **kwargs)
+
+    def remove(self):
+        """
+        Remove this colorbar from the figure.
+
+        If the colorbar was created with ``use_gridspec=True`` the previous
+        gridspec is restored.
+        """
+        if hasattr(self.ax, '_colorbar_info'):
+            parents = self.ax._colorbar_info['parents']
+            for a in parents:
+                if self.ax in a._colorbars:
+                    a._colorbars.remove(self.ax)
+
+        self.ax.remove()
+
+        self.mappable.callbacks.disconnect(self.mappable.colorbar_cid)
+        self.mappable.colorbar = None
+        self.mappable.colorbar_cid = None
+        # Remove the extension callbacks
+        self.ax.callbacks.disconnect(self._extend_cid1)
+        self.ax.callbacks.disconnect(self._extend_cid2)
+
+        try:
+            ax = self.mappable.axes
+        except AttributeError:
+            return
+        try:
+            subplotspec = self.ax.get_subplotspec().get_gridspec()._subplot_spec
+        except AttributeError:  # use_gridspec was False
+            pos = ax.get_position(original=True)
+            ax._set_position(pos)
+        else:  # use_gridspec was True
+            ax.set_subplotspec(subplotspec)
+
+    def _process_values(self):
+        """
+        Set `_boundaries` and `_values` based on the self.boundaries and
+        self.values if not None, or based on the size of the colormap and
+        the vmin/vmax of the norm.
+        """
+        if self.values is not None:
+            # set self._boundaries from the values...
+            self._values = np.array(self.values)
+            if self.boundaries is None:
+                # bracket values by 1/2 dv:
+                b = np.zeros(len(self.values) + 1)
+                b[1:-1] = 0.5 * (self._values[:-1] + self._values[1:])
+                b[0] = 2.0 * b[1] - b[2]
+                b[-1] = 2.0 * b[-2] - b[-3]
+                self._boundaries = b
+                return
+            self._boundaries = np.array(self.boundaries)
+            return
+
+        # otherwise values are set from the boundaries
+        if isinstance(self.norm, colors.BoundaryNorm):
+            b = self.norm.boundaries
+        elif isinstance(self.norm, colors.NoNorm):
+            # NoNorm has N blocks, so N+1 boundaries, centered on integers:
+            b = np.arange(self.cmap.N + 1) - .5
+        elif self.boundaries is not None:
+            b = self.boundaries
+        else:
+            # otherwise make the boundaries from the size of the cmap:
+            N = self.cmap.N + 1
+            b, _ = self._uniform_y(N)
+        # add extra boundaries if needed:
+        if self._extend_lower():
+            b = np.hstack((b[0] - 1, b))
+        if self._extend_upper():
+            b = np.hstack((b, b[-1] + 1))
+
+        # transform from 0-1 to vmin-vmax:
+        if self.mappable.get_array() is not None:
+            self.mappable.autoscale_None()
+        if not self.norm.scaled():
+            # If we still aren't scaled after autoscaling, use 0, 1 as default
+            self.norm.vmin = 0
+            self.norm.vmax = 1
+        self.norm.vmin, self.norm.vmax = mtransforms.nonsingular(
+            self.norm.vmin, self.norm.vmax, expander=0.1)
+        if (not isinstance(self.norm, colors.BoundaryNorm) and
+                (self.boundaries is None)):
+            b = self.norm.inverse(b)
+
+        self._boundaries = np.asarray(b, dtype=float)
+        self._values = 0.5 * (self._boundaries[:-1] + self._boundaries[1:])
+        if isinstance(self.norm, colors.NoNorm):
+            self._values = (self._values + 0.00001).astype(np.int16)
+
+    def _mesh(self):
+        """
+        Return the coordinate arrays for the colorbar pcolormesh/patches.
+
+        These are scaled between vmin and vmax, and already handle colorbar
+        orientation.
+        """
+        y, _ = self._proportional_y()
+        # Use the vmin and vmax of the colorbar, which may not be the same
+        # as the norm. There are situations where the colormap has a
+        # narrower range than the colorbar and we want to accommodate the
+        # extra contours.
+        if (isinstance(self.norm, (colors.BoundaryNorm, colors.NoNorm))
+                or self.boundaries is not None):
+            # not using a norm.
+            y = y * (self.vmax - self.vmin) + self.vmin
+        else:
+            # Update the norm values in a context manager as it is only
+            # a temporary change and we don't want to propagate any signals
+            # attached to the norm (callbacks.blocked).
+            with self.norm.callbacks.blocked(), \
+                    cbook._setattr_cm(self.norm,
+                                      vmin=self.vmin,
+                                      vmax=self.vmax):
+                y = self.norm.inverse(y)
+        self._y = y
+        X, Y = np.meshgrid([0., 1.], y)
+        if self.orientation == 'vertical':
+            return (X, Y)
+        else:
+            return (Y, X)
+
+    def _forward_boundaries(self, x):
+        # map boundaries equally between 0 and 1...
+        b = self._boundaries
+        y = np.interp(x, b, np.linspace(0, 1, len(b)))
+        # the following avoids ticks in the extends:
+        eps = (b[-1] - b[0]) * 1e-6
+        # map these _well_ out of bounds to keep any ticks out
+        # of the extends region...
+        y[x < b[0]-eps] = -1
+        y[x > b[-1]+eps] = 2
+        return y
+
+    def _inverse_boundaries(self, x):
+        # invert the above...
+        b = self._boundaries
+        return np.interp(x, np.linspace(0, 1, len(b)), b)
+
+    def _reset_locator_formatter_scale(self):
+        """
+        Reset the locator et al to defaults.  Any user-hardcoded changes
+        need to be re-entered if this gets called (either at init, or when
+        the mappable normal gets changed: Colorbar.update_normal)
+        """
+        self._process_values()
+        self._locator = None
+        self._minorlocator = None
+        self._formatter = None
+        self._minorformatter = None
+        if (isinstance(self.mappable, contour.ContourSet) and
+                isinstance(self.norm, colors.LogNorm)):
+            # if contours have lognorm, give them a log scale...
+            self._set_scale('log')
+        elif (self.boundaries is not None or
+                isinstance(self.norm, colors.BoundaryNorm)):
+            if self.spacing == 'uniform':
+                funcs = (self._forward_boundaries, self._inverse_boundaries)
+                self._set_scale('function', functions=funcs)
+            elif self.spacing == 'proportional':
+                self._set_scale('linear')
+        elif getattr(self.norm, '_scale', None):
+            # use the norm's scale (if it exists and is not None):
+            self._set_scale(self.norm._scale)
+        elif type(self.norm) is colors.Normalize:
+            # plain Normalize:
+            self._set_scale('linear')
+        else:
+            # norm._scale is None or not an attr: derive the scale from
+            # the Norm:
+            funcs = (self.norm, self.norm.inverse)
+            self._set_scale('function', functions=funcs)
+
+    def _locate(self, x):
+        """
+        Given a set of color data values, return their
+        corresponding colorbar data coordinates.
+        """
+        if isinstance(self.norm, (colors.NoNorm, colors.BoundaryNorm)):
+            b = self._boundaries
+            xn = x
+        else:
+            # Do calculations using normalized coordinates so
+            # as to make the interpolation more accurate.
+            b = self.norm(self._boundaries, clip=False).filled()
+            xn = self.norm(x, clip=False).filled()
+
+        bunique = b[self._inside]
+        yunique = self._y
+
+        z = np.interp(xn, bunique, yunique)
+        return z
+
+    # trivial helpers
+
+    def _uniform_y(self, N):
+        """
+        Return colorbar data coordinates for *N* uniformly
+        spaced boundaries, plus extension lengths if required.
+        """
+        automin = automax = 1. / (N - 1.)
+        extendlength = self._get_extension_lengths(self.extendfrac,
+                                                   automin, automax,
+                                                   default=0.05)
+        y = np.linspace(0, 1, N)
+        return y, extendlength
+
+    def _proportional_y(self):
+        """
+        Return colorbar data coordinates for the boundaries of
+        a proportional colorbar, plus extension lengths if required:
+        """
+        if (isinstance(self.norm, colors.BoundaryNorm) or
+                self.boundaries is not None):
+            y = (self._boundaries - self._boundaries[self._inside][0])
+            y = y / (self._boundaries[self._inside][-1] -
+                     self._boundaries[self._inside][0])
+            # need yscaled the same as the axes scale to get
+            # the extend lengths.
+            if self.spacing == 'uniform':
+                yscaled = self._forward_boundaries(self._boundaries)
+            else:
+                yscaled = y
+        else:
+            y = self.norm(self._boundaries.copy())
+            y = np.ma.filled(y, np.nan)
+            # the norm and the scale should be the same...
+            yscaled = y
+        y = y[self._inside]
+        yscaled = yscaled[self._inside]
+        # normalize from 0..1:
+        norm = colors.Normalize(y[0], y[-1])
+        y = np.ma.filled(norm(y), np.nan)
+        norm = colors.Normalize(yscaled[0], yscaled[-1])
+        yscaled = np.ma.filled(norm(yscaled), np.nan)
+        # make the lower and upper extend lengths proportional to the lengths
+        # of the first and last boundary spacing (if extendfrac='auto'):
+        automin = yscaled[1] - yscaled[0]
+        automax = yscaled[-1] - yscaled[-2]
+        extendlength = [0, 0]
+        if self._extend_lower() or self._extend_upper():
+            extendlength = self._get_extension_lengths(
+                    self.extendfrac, automin, automax, default=0.05)
+        return y, extendlength
+
+    def _get_extension_lengths(self, frac, automin, automax, default=0.05):
+        """
+        Return the lengths of colorbar extensions.
+
+        This is a helper method for _uniform_y and _proportional_y.
+        """
+        # Set the default value.
+        extendlength = np.array([default, default])
+        if isinstance(frac, str):
+            _api.check_in_list(['auto'], extendfrac=frac.lower())
+            # Use the provided values when 'auto' is required.
+            extendlength[:] = [automin, automax]
+        elif frac is not None:
+            try:
+                # Try to set min and max extension fractions directly.
+                extendlength[:] = frac
+                # If frac is a sequence containing None then NaN may
+                # be encountered. This is an error.
+                if np.isnan(extendlength).any():
+                    raise ValueError()
+            except (TypeError, ValueError) as err:
+                # Raise an error on encountering an invalid value for frac.
+                raise ValueError('invalid value for extendfrac') from err
+        return extendlength
+
+    def _extend_lower(self):
+        """Return whether the lower limit is open ended."""
+        minmax = "max" if self._long_axis().get_inverted() else "min"
+        return self.extend in ('both', minmax)
+
+    def _extend_upper(self):
+        """Return whether the upper limit is open ended."""
+        minmax = "min" if self._long_axis().get_inverted() else "max"
+        return self.extend in ('both', minmax)
+
+    def _long_axis(self):
+        """Return the long axis"""
+        if self.orientation == 'vertical':
+            return self.ax.yaxis
+        return self.ax.xaxis
+
+    def _short_axis(self):
+        """Return the short axis"""
+        if self.orientation == 'vertical':
+            return self.ax.xaxis
+        return self.ax.yaxis
+
+    def _get_view(self):
+        # docstring inherited
+        # An interactive view for a colorbar is the norm's vmin/vmax
+        return self.norm.vmin, self.norm.vmax
+
+    def _set_view(self, view):
+        # docstring inherited
+        # An interactive view for a colorbar is the norm's vmin/vmax
+        self.norm.vmin, self.norm.vmax = view
+
+    def _set_view_from_bbox(self, bbox, direction='in',
+                            mode=None, twinx=False, twiny=False):
+        # docstring inherited
+        # For colorbars, we use the zoom bbox to scale the norm's vmin/vmax
+        new_xbound, new_ybound = self.ax._prepare_view_from_bbox(
+            bbox, direction=direction, mode=mode, twinx=twinx, twiny=twiny)
+        if self.orientation == 'horizontal':
+            self.norm.vmin, self.norm.vmax = new_xbound
+        elif self.orientation == 'vertical':
+            self.norm.vmin, self.norm.vmax = new_ybound
+
+    def drag_pan(self, button, key, x, y):
+        # docstring inherited
+        points = self.ax._get_pan_points(button, key, x, y)
+        if points is not None:
+            if self.orientation == 'horizontal':
+                self.norm.vmin, self.norm.vmax = points[:, 0]
+            elif self.orientation == 'vertical':
+                self.norm.vmin, self.norm.vmax = points[:, 1]
+
+
+ColorbarBase = Colorbar  # Backcompat API
+
+
+def _normalize_location_orientation(location, orientation):
+    if location is None:
+        location = _get_ticklocation_from_orientation(orientation)
+    loc_settings = _api.check_getitem({
+        "left":   {"location": "left", "anchor": (1.0, 0.5),
+                   "panchor": (0.0, 0.5), "pad": 0.10},
+        "right":  {"location": "right", "anchor": (0.0, 0.5),
+                   "panchor": (1.0, 0.5), "pad": 0.05},
+        "top":    {"location": "top", "anchor": (0.5, 0.0),
+                   "panchor": (0.5, 1.0), "pad": 0.05},
+        "bottom": {"location": "bottom", "anchor": (0.5, 1.0),
+                   "panchor": (0.5, 0.0), "pad": 0.15},
+    }, location=location)
+    loc_settings["orientation"] = _get_orientation_from_location(location)
+    if orientation is not None and orientation != loc_settings["orientation"]:
+        # Allow the user to pass both if they are consistent.
+        raise TypeError("location and orientation are mutually exclusive")
+    return loc_settings
+
+
+def _get_orientation_from_location(location):
+    return _api.check_getitem(
+        {None: None, "left": "vertical", "right": "vertical",
+         "top": "horizontal", "bottom": "horizontal"}, location=location)
+
+
+def _get_ticklocation_from_orientation(orientation):
+    return _api.check_getitem(
+        {None: "right", "vertical": "right", "horizontal": "bottom"},
+        orientation=orientation)
+
+
+@_docstring.interpd
+def make_axes(parents, location=None, orientation=None, fraction=0.15,
+              shrink=1.0, aspect=20, **kwargs):
+    """
+    Create an `~.axes.Axes` suitable for a colorbar.
+
+    The Axes is placed in the figure of the *parents* Axes, by resizing and
+    repositioning *parents*.
+
+    Parameters
+    ----------
+    parents : `~matplotlib.axes.Axes` or iterable or `numpy.ndarray` of `~.axes.Axes`
+        The Axes to use as parents for placing the colorbar.
+    %(_make_axes_kw_doc)s
+
+    Returns
+    -------
+    cax : `~matplotlib.axes.Axes`
+        The child Axes.
+    kwargs : dict
+        The reduced keyword dictionary to be passed when creating the colorbar
+        instance.
+    """
+    loc_settings = _normalize_location_orientation(location, orientation)
+    # put appropriate values into the kwargs dict for passing back to
+    # the Colorbar class
+    kwargs['orientation'] = loc_settings['orientation']
+    location = kwargs['ticklocation'] = loc_settings['location']
+
+    anchor = kwargs.pop('anchor', loc_settings['anchor'])
+    panchor = kwargs.pop('panchor', loc_settings['panchor'])
+    aspect0 = aspect
+    # turn parents into a list if it is not already.  Note we cannot
+    # use .flatten or .ravel as these copy the references rather than
+    # reuse them, leading to a memory leak
+    if isinstance(parents, np.ndarray):
+        parents = list(parents.flat)
+    elif np.iterable(parents):
+        parents = list(parents)
+    else:
+        parents = [parents]
+
+    fig = parents[0].get_figure()
+
+    pad0 = 0.05 if fig.get_constrained_layout() else loc_settings['pad']
+    pad = kwargs.pop('pad', pad0)
+
+    if not all(fig is ax.get_figure() for ax in parents):
+        raise ValueError('Unable to create a colorbar Axes as not all '
+                         'parents share the same figure.')
+
+    # take a bounding box around all of the given Axes
+    parents_bbox = mtransforms.Bbox.union(
+        [ax.get_position(original=True).frozen() for ax in parents])
+
+    pb = parents_bbox
+    if location in ('left', 'right'):
+        if location == 'left':
+            pbcb, _, pb1 = pb.splitx(fraction, fraction + pad)
+        else:
+            pb1, _, pbcb = pb.splitx(1 - fraction - pad, 1 - fraction)
+        pbcb = pbcb.shrunk(1.0, shrink).anchored(anchor, pbcb)
+    else:
+        if location == 'bottom':
+            pbcb, _, pb1 = pb.splity(fraction, fraction + pad)
+        else:
+            pb1, _, pbcb = pb.splity(1 - fraction - pad, 1 - fraction)
+        pbcb = pbcb.shrunk(shrink, 1.0).anchored(anchor, pbcb)
+
+        # define the aspect ratio in terms of y's per x rather than x's per y
+        aspect = 1.0 / aspect
+
+    # define a transform which takes us from old axes coordinates to
+    # new axes coordinates
+    shrinking_trans = mtransforms.BboxTransform(parents_bbox, pb1)
+
+    # transform each of the Axes in parents using the new transform
+    for ax in parents:
+        new_posn = shrinking_trans.transform(ax.get_position(original=True))
+        new_posn = mtransforms.Bbox(new_posn)
+        ax._set_position(new_posn)
+        if panchor is not False:
+            ax.set_anchor(panchor)
+
+    cax = fig.add_axes(pbcb, label="<colorbar>")
+    for a in parents:
+        # tell the parent it has a colorbar
+        a._colorbars += [cax]
+    cax._colorbar_info = dict(
+        parents=parents,
+        location=location,
+        shrink=shrink,
+        anchor=anchor,
+        panchor=panchor,
+        fraction=fraction,
+        aspect=aspect0,
+        pad=pad)
+    # and we need to set the aspect ratio by hand...
+    cax.set_anchor(anchor)
+    cax.set_box_aspect(aspect)
+    cax.set_aspect('auto')
+
+    return cax, kwargs
+
+
+@_docstring.interpd
+def make_axes_gridspec(parent, *, location=None, orientation=None,
+                       fraction=0.15, shrink=1.0, aspect=20, **kwargs):
+    """
+    Create an `~.axes.Axes` suitable for a colorbar.
+
+    The Axes is placed in the figure of the *parent* Axes, by resizing and
+    repositioning *parent*.
+
+    This function is similar to `.make_axes` and mostly compatible with it.
+    Primary differences are
+
+    - `.make_axes_gridspec` requires the *parent* to have a subplotspec.
+    - `.make_axes` positions the Axes in figure coordinates;
+      `.make_axes_gridspec` positions it using a subplotspec.
+    - `.make_axes` updates the position of the parent.  `.make_axes_gridspec`
+      replaces the parent gridspec with a new one.
+
+    Parameters
+    ----------
+    parent : `~matplotlib.axes.Axes`
+        The Axes to use as parent for placing the colorbar.
+    %(_make_axes_kw_doc)s
+
+    Returns
+    -------
+    cax : `~matplotlib.axes.Axes`
+        The child Axes.
+    kwargs : dict
+        The reduced keyword dictionary to be passed when creating the colorbar
+        instance.
+    """
+
+    loc_settings = _normalize_location_orientation(location, orientation)
+    kwargs['orientation'] = loc_settings['orientation']
+    location = kwargs['ticklocation'] = loc_settings['location']
+
+    aspect0 = aspect
+    anchor = kwargs.pop('anchor', loc_settings['anchor'])
+    panchor = kwargs.pop('panchor', loc_settings['panchor'])
+    pad = kwargs.pop('pad', loc_settings["pad"])
+    wh_space = 2 * pad / (1 - pad)
+
+    if location in ('left', 'right'):
+        gs = parent.get_subplotspec().subgridspec(
+            3, 2, wspace=wh_space, hspace=0,
+            height_ratios=[(1-anchor[1])*(1-shrink), shrink, anchor[1]*(1-shrink)])
+        if location == 'left':
+            gs.set_width_ratios([fraction, 1 - fraction - pad])
+            ss_main = gs[:, 1]
+            ss_cb = gs[1, 0]
+        else:
+            gs.set_width_ratios([1 - fraction - pad, fraction])
+            ss_main = gs[:, 0]
+            ss_cb = gs[1, 1]
+    else:
+        gs = parent.get_subplotspec().subgridspec(
+            2, 3, hspace=wh_space, wspace=0,
+            width_ratios=[anchor[0]*(1-shrink), shrink, (1-anchor[0])*(1-shrink)])
+        if location == 'top':
+            gs.set_height_ratios([fraction, 1 - fraction - pad])
+            ss_main = gs[1, :]
+            ss_cb = gs[0, 1]
+        else:
+            gs.set_height_ratios([1 - fraction - pad, fraction])
+            ss_main = gs[0, :]
+            ss_cb = gs[1, 1]
+        aspect = 1 / aspect
+
+    parent.set_subplotspec(ss_main)
+    if panchor is not False:
+        parent.set_anchor(panchor)
+
+    fig = parent.get_figure()
+    cax = fig.add_subplot(ss_cb, label="<colorbar>")
+    cax.set_anchor(anchor)
+    cax.set_box_aspect(aspect)
+    cax.set_aspect('auto')
+    cax._colorbar_info = dict(
+        location=location,
+        parents=[parent],
+        shrink=shrink,
+        anchor=anchor,
+        panchor=panchor,
+        fraction=fraction,
+        aspect=aspect0,
+        pad=pad)
+
+    return cax, kwargs

llava_next/lib/python3.10/site-packages/matplotlib/colors.pyi

@@ -0,0 +1,354 @@
+from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
+from matplotlib import cbook, scale
+import re
+
+from typing import Any, Literal, overload
+from .typing import ColorType
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+# Explicitly export colors dictionaries which are imported in the impl
+BASE_COLORS: dict[str, ColorType]
+CSS4_COLORS: dict[str, ColorType]
+TABLEAU_COLORS: dict[str, ColorType]
+XKCD_COLORS: dict[str, ColorType]
+
+class _ColorMapping(dict[str, ColorType]):
+    cache: dict[tuple[ColorType, float | None], tuple[float, float, float, float]]
+    def __init__(self, mapping) -> None: ...
+    def __setitem__(self, key, value) -> None: ...
+    def __delitem__(self, key) -> None: ...
+
+def get_named_colors_mapping() -> _ColorMapping: ...
+
+class ColorSequenceRegistry(Mapping):
+    def __init__(self) -> None: ...
+    def __getitem__(self, item: str) -> list[ColorType]: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def __len__(self) -> int: ...
+    def register(self, name: str, color_list: Iterable[ColorType]) -> None: ...
+    def unregister(self, name: str) -> None: ...
+
+_color_sequences: ColorSequenceRegistry = ...
+
+def is_color_like(c: Any) -> bool: ...
+def same_color(c1: ColorType, c2: ColorType) -> bool: ...
+def to_rgba(
+    c: ColorType, alpha: float | None = ...
+) -> tuple[float, float, float, float]: ...
+def to_rgba_array(
+    c: ColorType | ArrayLike, alpha: float | ArrayLike | None = ...
+) -> np.ndarray: ...
+def to_rgb(c: ColorType) -> tuple[float, float, float]: ...
+def to_hex(c: ColorType, keep_alpha: bool = ...) -> str: ...
+
+cnames: dict[str, ColorType]
+hexColorPattern: re.Pattern
+rgb2hex = to_hex
+hex2color = to_rgb
+
+class ColorConverter:
+    colors: _ColorMapping
+    cache: dict[tuple[ColorType, float | None], tuple[float, float, float, float]]
+    @staticmethod
+    def to_rgb(c: ColorType) -> tuple[float, float, float]: ...
+    @staticmethod
+    def to_rgba(
+        c: ColorType, alpha: float | None = ...
+    ) -> tuple[float, float, float, float]: ...
+    @staticmethod
+    def to_rgba_array(
+        c: ColorType | ArrayLike, alpha: float | ArrayLike | None = ...
+    ) -> np.ndarray: ...
+
+colorConverter: ColorConverter
+
+class Colormap:
+    name: str
+    N: int
+    colorbar_extend: bool
+    def __init__(self, name: str, N: int = ...) -> None: ...
+    @overload
+    def __call__(
+        self, X: Sequence[float] | np.ndarray, alpha: ArrayLike | None = ..., bytes: bool = ...
+    ) -> np.ndarray: ...
+    @overload
+    def __call__(
+        self, X: float, alpha: float | None = ..., bytes: bool = ...
+    ) -> tuple[float, float, float, float]: ...
+    @overload
+    def __call__(
+        self, X: ArrayLike, alpha: ArrayLike | None = ..., bytes: bool = ...
+    ) -> tuple[float, float, float, float] | np.ndarray: ...
+    def __copy__(self) -> Colormap: ...
+    def __eq__(self, other: object) -> bool: ...
+    def get_bad(self) -> np.ndarray: ...
+    def set_bad(self, color: ColorType = ..., alpha: float | None = ...) -> None: ...
+    def get_under(self) -> np.ndarray: ...
+    def set_under(self, color: ColorType = ..., alpha: float | None = ...) -> None: ...
+    def get_over(self) -> np.ndarray: ...
+    def set_over(self, color: ColorType = ..., alpha: float | None = ...) -> None: ...
+    def set_extremes(
+        self,
+        *,
+        bad: ColorType | None = ...,
+        under: ColorType | None = ...,
+        over: ColorType | None = ...
+    ) -> None: ...
+    def with_extremes(
+        self,
+        *,
+        bad: ColorType | None = ...,
+        under: ColorType | None = ...,
+        over: ColorType | None = ...
+    ) -> Colormap: ...
+    def is_gray(self) -> bool: ...
+    def resampled(self, lutsize: int) -> Colormap: ...
+    def reversed(self, name: str | None = ...) -> Colormap: ...
+    def _repr_html_(self) -> str: ...
+    def _repr_png_(self) -> bytes: ...
+    def copy(self) -> Colormap: ...
+
+class LinearSegmentedColormap(Colormap):
+    monochrome: bool
+    def __init__(
+        self,
+        name: str,
+        segmentdata: dict[
+            Literal["red", "green", "blue", "alpha"], Sequence[tuple[float, ...]]
+        ],
+        N: int = ...,
+        gamma: float = ...,
+    ) -> None: ...
+    def set_gamma(self, gamma: float) -> None: ...
+    @staticmethod
+    def from_list(
+        name: str, colors: ArrayLike | Sequence[tuple[float, ColorType]], N: int = ..., gamma: float = ...
+    ) -> LinearSegmentedColormap: ...
+    def resampled(self, lutsize: int) -> LinearSegmentedColormap: ...
+    def reversed(self, name: str | None = ...) -> LinearSegmentedColormap: ...
+
+class ListedColormap(Colormap):
+    monochrome: bool
+    colors: ArrayLike | ColorType
+    def __init__(
+        self, colors: ArrayLike | ColorType, name: str = ..., N: int | None = ...
+    ) -> None: ...
+    def resampled(self, lutsize: int) -> ListedColormap: ...
+    def reversed(self, name: str | None = ...) -> ListedColormap: ...
+
+class Normalize:
+    callbacks: cbook.CallbackRegistry
+    def __init__(
+        self, vmin: float | None = ..., vmax: float | None = ..., clip: bool = ...
+    ) -> None: ...
+    @property
+    def vmin(self) -> float | None: ...
+    @vmin.setter
+    def vmin(self, value: float | None) -> None: ...
+    @property
+    def vmax(self) -> float | None: ...
+    @vmax.setter
+    def vmax(self, value: float | None) -> None: ...
+    @property
+    def clip(self) -> bool: ...
+    @clip.setter
+    def clip(self, value: bool) -> None: ...
+    @staticmethod
+    def process_value(value: ArrayLike) -> tuple[np.ma.MaskedArray, bool]: ...
+    @overload
+    def __call__(self, value: float, clip: bool | None = ...) -> float: ...
+    @overload
+    def __call__(self, value: np.ndarray, clip: bool | None = ...) -> np.ma.MaskedArray: ...
+    @overload
+    def __call__(self, value: ArrayLike, clip: bool | None = ...) -> ArrayLike: ...
+    @overload
+    def inverse(self, value: float) -> float: ...
+    @overload
+    def inverse(self, value: np.ndarray) -> np.ma.MaskedArray: ...
+    @overload
+    def inverse(self, value: ArrayLike) -> ArrayLike: ...
+    def autoscale(self, A: ArrayLike) -> None: ...
+    def autoscale_None(self, A: ArrayLike) -> None: ...
+    def scaled(self) -> bool: ...
+
+class TwoSlopeNorm(Normalize):
+    def __init__(
+        self, vcenter: float, vmin: float | None = ..., vmax: float | None = ...
+    ) -> None: ...
+    @property
+    def vcenter(self) -> float: ...
+    @vcenter.setter
+    def vcenter(self, value: float) -> None: ...
+    def autoscale_None(self, A: ArrayLike) -> None: ...
+
+class CenteredNorm(Normalize):
+    def __init__(
+        self, vcenter: float = ..., halfrange: float | None = ..., clip: bool = ...
+    ) -> None: ...
+    @property
+    def vcenter(self) -> float: ...
+    @vcenter.setter
+    def vcenter(self, vcenter: float) -> None: ...
+    @property
+    def halfrange(self) -> float: ...
+    @halfrange.setter
+    def halfrange(self, halfrange: float) -> None: ...
+
+@overload
+def make_norm_from_scale(
+    scale_cls: type[scale.ScaleBase],
+    base_norm_cls: type[Normalize],
+    *,
+    init: Callable | None = ...
+) -> type[Normalize]: ...
+@overload
+def make_norm_from_scale(
+    scale_cls: type[scale.ScaleBase],
+    base_norm_cls: None = ...,
+    *,
+    init: Callable | None = ...
+) -> Callable[[type[Normalize]], type[Normalize]]: ...
+
+class FuncNorm(Normalize):
+    def __init__(
+            self,
+            functions: tuple[Callable, Callable],
+            vmin: float | None = ...,
+            vmax: float | None = ...,
+            clip: bool = ...,
+    ) -> None: ...
+class LogNorm(Normalize): ...
+
+class SymLogNorm(Normalize):
+    def __init__(
+            self,
+            linthresh: float,
+            linscale: float = ...,
+            vmin: float | None = ...,
+            vmax: float | None = ...,
+            clip: bool = ...,
+            *,
+            base: float = ...,
+    ) -> None: ...
+    @property
+    def linthresh(self) -> float: ...
+    @linthresh.setter
+    def linthresh(self, value: float) -> None: ...
+
+class AsinhNorm(Normalize):
+    def __init__(
+        self,
+        linear_width: float = ...,
+        vmin: float | None = ...,
+        vmax: float | None = ...,
+        clip: bool = ...,
+    ) -> None: ...
+    @property
+    def linear_width(self) -> float: ...
+    @linear_width.setter
+    def linear_width(self, value: float) -> None: ...
+
+class PowerNorm(Normalize):
+    gamma: float
+    def __init__(
+        self,
+        gamma: float,
+        vmin: float | None = ...,
+        vmax: float | None = ...,
+        clip: bool = ...,
+    ) -> None: ...
+
+class BoundaryNorm(Normalize):
+    boundaries: np.ndarray
+    N: int
+    Ncmap: int
+    extend: Literal["neither", "both", "min", "max"]
+    def __init__(
+        self,
+        boundaries: ArrayLike,
+        ncolors: int,
+        clip: bool = ...,
+        *,
+        extend: Literal["neither", "both", "min", "max"] = ...
+    ) -> None: ...
+
+class NoNorm(Normalize): ...
+
+def rgb_to_hsv(arr: ArrayLike) -> np.ndarray: ...
+def hsv_to_rgb(hsv: ArrayLike) -> np.ndarray: ...
+
+class LightSource:
+    azdeg: float
+    altdeg: float
+    hsv_min_val: float
+    hsv_max_val: float
+    hsv_min_sat: float
+    hsv_max_sat: float
+    def __init__(
+        self,
+        azdeg: float = ...,
+        altdeg: float = ...,
+        hsv_min_val: float = ...,
+        hsv_max_val: float = ...,
+        hsv_min_sat: float = ...,
+        hsv_max_sat: float = ...,
+    ) -> None: ...
+    @property
+    def direction(self) -> np.ndarray: ...
+    def hillshade(
+        self,
+        elevation: ArrayLike,
+        vert_exag: float = ...,
+        dx: float = ...,
+        dy: float = ...,
+        fraction: float = ...,
+    ) -> np.ndarray: ...
+    def shade_normals(
+        self, normals: np.ndarray, fraction: float = ...
+    ) -> np.ndarray: ...
+    def shade(
+        self,
+        data: ArrayLike,
+        cmap: Colormap,
+        norm: Normalize | None = ...,
+        blend_mode: Literal["hsv", "overlay", "soft"] | Callable = ...,
+        vmin: float | None = ...,
+        vmax: float | None = ...,
+        vert_exag: float = ...,
+        dx: float = ...,
+        dy: float = ...,
+        fraction: float = ...,
+        **kwargs
+    ) -> np.ndarray: ...
+    def shade_rgb(
+        self,
+        rgb: ArrayLike,
+        elevation: ArrayLike,
+        fraction: float = ...,
+        blend_mode: Literal["hsv", "overlay", "soft"] | Callable = ...,
+        vert_exag: float = ...,
+        dx: float = ...,
+        dy: float = ...,
+        **kwargs
+    ) -> np.ndarray: ...
+    def blend_hsv(
+        self,
+        rgb: ArrayLike,
+        intensity: ArrayLike,
+        hsv_max_sat: float | None = ...,
+        hsv_max_val: float | None = ...,
+        hsv_min_val: float | None = ...,
+        hsv_min_sat: float | None = ...,
+    ) -> ArrayLike: ...
+    def blend_soft_light(
+        self, rgb: np.ndarray, intensity: np.ndarray
+    ) -> np.ndarray: ...
+    def blend_overlay(self, rgb: np.ndarray, intensity: np.ndarray) -> np.ndarray: ...
+
+def from_levels_and_colors(
+    levels: Sequence[float],
+    colors: Sequence[ColorType],
+    extend: Literal["neither", "min", "max", "both"] = ...,
+) -> tuple[ListedColormap, BoundaryNorm]: ...

llava_next/lib/python3.10/site-packages/matplotlib/container.py

@@ -0,0 +1,141 @@
+from matplotlib import cbook
+from matplotlib.artist import Artist
+
+
+class Container(tuple):
+    """
+    Base class for containers.
+
+    Containers are classes that collect semantically related Artists such as
+    the bars of a bar plot.
+    """
+
+    def __repr__(self):
+        return f"<{type(self).__name__} object of {len(self)} artists>"
+
+    def __new__(cls, *args, **kwargs):
+        return tuple.__new__(cls, args[0])
+
+    def __init__(self, kl, label=None):
+        self._callbacks = cbook.CallbackRegistry(signals=["pchanged"])
+        self._remove_method = None
+        self._label = str(label) if label is not None else None
+
+    def remove(self):
+        for c in cbook.flatten(
+                self, scalarp=lambda x: isinstance(x, Artist)):
+            if c is not None:
+                c.remove()
+        if self._remove_method:
+            self._remove_method(self)
+
+    def get_children(self):
+        return [child for child in cbook.flatten(self) if child is not None]
+
+    get_label = Artist.get_label
+    set_label = Artist.set_label
+    add_callback = Artist.add_callback
+    remove_callback = Artist.remove_callback
+    pchanged = Artist.pchanged
+
+
+class BarContainer(Container):
+    """
+    Container for the artists of bar plots (e.g. created by `.Axes.bar`).
+
+    The container can be treated as a tuple of the *patches* themselves.
+    Additionally, you can access these and further parameters by the
+    attributes.
+
+    Attributes
+    ----------
+    patches : list of :class:`~matplotlib.patches.Rectangle`
+        The artists of the bars.
+
+    errorbar : None or :class:`~matplotlib.container.ErrorbarContainer`
+        A container for the error bar artists if error bars are present.
+        *None* otherwise.
+
+    datavalues : None or array-like
+        The underlying data values corresponding to the bars.
+
+    orientation : {'vertical', 'horizontal'}, default: None
+        If 'vertical', the bars are assumed to be vertical.
+        If 'horizontal', the bars are assumed to be horizontal.
+
+    """
+
+    def __init__(self, patches, errorbar=None, *, datavalues=None,
+                 orientation=None, **kwargs):
+        self.patches = patches
+        self.errorbar = errorbar
+        self.datavalues = datavalues
+        self.orientation = orientation
+        super().__init__(patches, **kwargs)
+
+
+class ErrorbarContainer(Container):
+    """
+    Container for the artists of error bars (e.g. created by `.Axes.errorbar`).
+
+    The container can be treated as the *lines* tuple itself.
+    Additionally, you can access these and further parameters by the
+    attributes.
+
+    Attributes
+    ----------
+    lines : tuple
+        Tuple of ``(data_line, caplines, barlinecols)``.
+
+        - data_line : A `~matplotlib.lines.Line2D` instance of x, y plot markers
+          and/or line.
+        - caplines : A tuple of `~matplotlib.lines.Line2D` instances of the error
+          bar caps.
+        - barlinecols : A tuple of `~matplotlib.collections.LineCollection` with the
+          horizontal and vertical error ranges.
+
+    has_xerr, has_yerr : bool
+        ``True`` if the errorbar has x/y errors.
+
+    """
+
+    def __init__(self, lines, has_xerr=False, has_yerr=False, **kwargs):
+        self.lines = lines
+        self.has_xerr = has_xerr
+        self.has_yerr = has_yerr
+        super().__init__(lines, **kwargs)
+
+
+class StemContainer(Container):
+    """
+    Container for the artists created in a :meth:`.Axes.stem` plot.
+
+    The container can be treated like a namedtuple ``(markerline, stemlines,
+    baseline)``.
+
+    Attributes
+    ----------
+    markerline : `~matplotlib.lines.Line2D`
+        The artist of the markers at the stem heads.
+
+    stemlines : `~matplotlib.collections.LineCollection`
+        The artists of the vertical lines for all stems.
+
+    baseline : `~matplotlib.lines.Line2D`
+        The artist of the horizontal baseline.
+    """
+    def __init__(self, markerline_stemlines_baseline, **kwargs):
+        """
+        Parameters
+        ----------
+        markerline_stemlines_baseline : tuple
+            Tuple of ``(markerline, stemlines, baseline)``.
+            ``markerline`` contains the `.Line2D` of the markers,
+            ``stemlines`` is a `.LineCollection` of the main lines,
+            ``baseline`` is the `.Line2D` of the baseline.
+        """
+        markerline, stemlines, baseline = markerline_stemlines_baseline
+        self.markerline = markerline
+        self.stemlines = stemlines
+        self.baseline = baseline
+        super().__init__(markerline_stemlines_baseline, **kwargs)

llava_next/lib/python3.10/site-packages/matplotlib/dviread.py

@@ -0,0 +1,1107 @@
+"""
+A module for reading dvi files output by TeX. Several limitations make
+this not (currently) useful as a general-purpose dvi preprocessor, but
+it is currently used by the pdf backend for processing usetex text.
+
+Interface::
+
+  with Dvi(filename, 72) as dvi:
+      # iterate over pages:
+      for page in dvi:
+          w, h, d = page.width, page.height, page.descent
+          for x, y, font, glyph, width in page.text:
+              fontname = font.texname
+              pointsize = font.size
+              ...
+          for x, y, height, width in page.boxes:
+              ...
+"""
+
+from collections import namedtuple
+import enum
+from functools import lru_cache, partial, wraps
+import logging
+import os
+from pathlib import Path
+import re
+import struct
+import subprocess
+import sys
+
+import numpy as np
+
+from matplotlib import _api, cbook
+
+_log = logging.getLogger(__name__)
+
+# Many dvi related files are looked for by external processes, require
+# additional parsing, and are used many times per rendering, which is why they
+# are cached using lru_cache().
+
+# Dvi is a bytecode format documented in
+# https://ctan.org/pkg/dvitype
+# https://texdoc.org/serve/dvitype.pdf/0
+#
+# The file consists of a preamble, some number of pages, a postamble,
+# and a finale. Different opcodes are allowed in different contexts,
+# so the Dvi object has a parser state:
+#
+#   pre:       expecting the preamble
+#   outer:     between pages (followed by a page or the postamble,
+#              also e.g. font definitions are allowed)
+#   page:      processing a page
+#   post_post: state after the postamble (our current implementation
+#              just stops reading)
+#   finale:    the finale (unimplemented in our current implementation)
+
+_dvistate = enum.Enum('DviState', 'pre outer inpage post_post finale')
+
+# The marks on a page consist of text and boxes. A page also has dimensions.
+Page = namedtuple('Page', 'text boxes height width descent')
+Box = namedtuple('Box', 'x y height width')
+
+
+# Also a namedtuple, for backcompat.
+class Text(namedtuple('Text', 'x y font glyph width')):
+    """
+    A glyph in the dvi file.
+
+    The *x* and *y* attributes directly position the glyph.  The *font*,
+    *glyph*, and *width* attributes are kept public for back-compatibility,
+    but users wanting to draw the glyph themselves are encouraged to instead
+    load the font specified by `font_path` at `font_size`, warp it with the
+    effects specified by `font_effects`, and load the glyph specified by
+    `glyph_name_or_index`.
+    """
+
+    def _get_pdftexmap_entry(self):
+        return PsfontsMap(find_tex_file("pdftex.map"))[self.font.texname]
+
+    @property
+    def font_path(self):
+        """The `~pathlib.Path` to the font for this glyph."""
+        psfont = self._get_pdftexmap_entry()
+        if psfont.filename is None:
+            raise ValueError("No usable font file found for {} ({}); "
+                             "the font may lack a Type-1 version"
+                             .format(psfont.psname.decode("ascii"),
+                                     psfont.texname.decode("ascii")))
+        return Path(psfont.filename)
+
+    @property
+    def font_size(self):
+        """The font size."""
+        return self.font.size
+
+    @property
+    def font_effects(self):
+        """
+        The "font effects" dict for this glyph.
+
+        This dict contains the values for this glyph of SlantFont and
+        ExtendFont (if any), read off :file:`pdftex.map`.
+        """
+        return self._get_pdftexmap_entry().effects
+
+    @property
+    def glyph_name_or_index(self):
+        """
+        Either the glyph name or the native charmap glyph index.
+
+        If :file:`pdftex.map` specifies an encoding for this glyph's font, that
+        is a mapping of glyph indices to Adobe glyph names; use it to convert
+        dvi indices to glyph names.  Callers can then convert glyph names to
+        glyph indices (with FT_Get_Name_Index/get_name_index), and load the
+        glyph using FT_Load_Glyph/load_glyph.
+
+        If :file:`pdftex.map` specifies no encoding, the indices directly map
+        to the font's "native" charmap; glyphs should directly load using
+        FT_Load_Char/load_char after selecting the native charmap.
+        """
+        entry = self._get_pdftexmap_entry()
+        return (_parse_enc(entry.encoding)[self.glyph]
+                if entry.encoding is not None else self.glyph)
+
+
+# Opcode argument parsing
+#
+# Each of the following functions takes a Dvi object and delta, which is the
+# difference between the opcode and the minimum opcode with the same meaning.
+# Dvi opcodes often encode the number of argument bytes in this delta.
+_arg_mapping = dict(
+    # raw: Return delta as is.
+    raw=lambda dvi, delta: delta,
+    # u1: Read 1 byte as an unsigned number.
+    u1=lambda dvi, delta: dvi._arg(1, signed=False),
+    # u4: Read 4 bytes as an unsigned number.
+    u4=lambda dvi, delta: dvi._arg(4, signed=False),
+    # s4: Read 4 bytes as a signed number.
+    s4=lambda dvi, delta: dvi._arg(4, signed=True),
+    # slen: Read delta bytes as a signed number, or None if delta is None.
+    slen=lambda dvi, delta: dvi._arg(delta, signed=True) if delta else None,
+    # slen1: Read (delta + 1) bytes as a signed number.
+    slen1=lambda dvi, delta: dvi._arg(delta + 1, signed=True),
+    # ulen1: Read (delta + 1) bytes as an unsigned number.
+    ulen1=lambda dvi, delta: dvi._arg(delta + 1, signed=False),
+    # olen1: Read (delta + 1) bytes as an unsigned number if less than 4 bytes,
+    # as a signed number if 4 bytes.
+    olen1=lambda dvi, delta: dvi._arg(delta + 1, signed=(delta == 3)),
+)
+
+
+def _dispatch(table, min, max=None, state=None, args=('raw',)):
+    """
+    Decorator for dispatch by opcode. Sets the values in *table*
+    from *min* to *max* to this method, adds a check that the Dvi state
+    matches *state* if not None, reads arguments from the file according
+    to *args*.
+
+    Parameters
+    ----------
+    table : dict[int, callable]
+        The dispatch table to be filled in.
+
+    min, max : int
+        Range of opcodes that calls the registered function; *max* defaults to
+        *min*.
+
+    state : _dvistate, optional
+        State of the Dvi object in which these opcodes are allowed.
+
+    args : list[str], default: ['raw']
+        Sequence of argument specifications:
+
+        - 'raw': opcode minus minimum
+        - 'u1': read one unsigned byte
+        - 'u4': read four bytes, treat as an unsigned number
+        - 's4': read four bytes, treat as a signed number
+        - 'slen': read (opcode - minimum) bytes, treat as signed
+        - 'slen1': read (opcode - minimum + 1) bytes, treat as signed
+        - 'ulen1': read (opcode - minimum + 1) bytes, treat as unsigned
+        - 'olen1': read (opcode - minimum + 1) bytes, treat as unsigned
+          if under four bytes, signed if four bytes
+    """
+    def decorate(method):
+        get_args = [_arg_mapping[x] for x in args]
+
+        @wraps(method)
+        def wrapper(self, byte):
+            if state is not None and self.state != state:
+                raise ValueError("state precondition failed")
+            return method(self, *[f(self, byte-min) for f in get_args])
+        if max is None:
+            table[min] = wrapper
+        else:
+            for i in range(min, max+1):
+                assert table[i] is None
+                table[i] = wrapper
+        return wrapper
+    return decorate
+
+
+class Dvi:
+    """
+    A reader for a dvi ("device-independent") file, as produced by TeX.
+
+    The current implementation can only iterate through pages in order,
+    and does not even attempt to verify the postamble.
+
+    This class can be used as a context manager to close the underlying
+    file upon exit. Pages can be read via iteration. Here is an overly
+    simple way to extract text without trying to detect whitespace::
+
+        >>> with matplotlib.dviread.Dvi('input.dvi', 72) as dvi:
+        ...     for page in dvi:
+        ...         print(''.join(chr(t.glyph) for t in page.text))
+    """
+    # dispatch table
+    _dtable = [None] * 256
+    _dispatch = partial(_dispatch, _dtable)
+
+    def __init__(self, filename, dpi):
+        """
+        Read the data from the file named *filename* and convert
+        TeX's internal units to units of *dpi* per inch.
+        *dpi* only sets the units and does not limit the resolution.
+        Use None to return TeX's internal units.
+        """
+        _log.debug('Dvi: %s', filename)
+        self.file = open(filename, 'rb')
+        self.dpi = dpi
+        self.fonts = {}
+        self.state = _dvistate.pre
+
+    def __enter__(self):
+        """Context manager enter method, does nothing."""
+        return self
+
+    def __exit__(self, etype, evalue, etrace):
+        """
+        Context manager exit method, closes the underlying file if it is open.
+        """
+        self.close()
+
+    def __iter__(self):
+        """
+        Iterate through the pages of the file.
+
+        Yields
+        ------
+        Page
+            Details of all the text and box objects on the page.
+            The Page tuple contains lists of Text and Box tuples and
+            the page dimensions, and the Text and Box tuples contain
+            coordinates transformed into a standard Cartesian
+            coordinate system at the dpi value given when initializing.
+            The coordinates are floating point numbers, but otherwise
+            precision is not lost and coordinate values are not clipped to
+            integers.
+        """
+        while self._read():
+            yield self._output()
+
+    def close(self):
+        """Close the underlying file if it is open."""
+        if not self.file.closed:
+            self.file.close()
+
+    def _output(self):
+        """
+        Output the text and boxes belonging to the most recent page.
+        page = dvi._output()
+        """
+        minx, miny, maxx, maxy = np.inf, np.inf, -np.inf, -np.inf
+        maxy_pure = -np.inf
+        for elt in self.text + self.boxes:
+            if isinstance(elt, Box):
+                x, y, h, w = elt
+                e = 0  # zero depth
+            else:  # glyph
+                x, y, font, g, w = elt
+                h, e = font._height_depth_of(g)
+            minx = min(minx, x)
+            miny = min(miny, y - h)
+            maxx = max(maxx, x + w)
+            maxy = max(maxy, y + e)
+            maxy_pure = max(maxy_pure, y)
+        if self._baseline_v is not None:
+            maxy_pure = self._baseline_v  # This should normally be the case.
+            self._baseline_v = None
+
+        if not self.text and not self.boxes:  # Avoid infs/nans from inf+/-inf.
+            return Page(text=[], boxes=[], width=0, height=0, descent=0)
+
+        if self.dpi is None:
+            # special case for ease of debugging: output raw dvi coordinates
+            return Page(text=self.text, boxes=self.boxes,
+                        width=maxx-minx, height=maxy_pure-miny,
+                        descent=maxy-maxy_pure)
+
+        # convert from TeX's "scaled points" to dpi units
+        d = self.dpi / (72.27 * 2**16)
+        descent = (maxy - maxy_pure) * d
+
+        text = [Text((x-minx)*d, (maxy-y)*d - descent, f, g, w*d)
+                for (x, y, f, g, w) in self.text]
+        boxes = [Box((x-minx)*d, (maxy-y)*d - descent, h*d, w*d)
+                 for (x, y, h, w) in self.boxes]
+
+        return Page(text=text, boxes=boxes, width=(maxx-minx)*d,
+                    height=(maxy_pure-miny)*d, descent=descent)
+
+    def _read(self):
+        """
+        Read one page from the file. Return True if successful,
+        False if there were no more pages.
+        """
+        # Pages appear to start with the sequence
+        #   bop (begin of page)
+        #   xxx comment
+        #   <push, ..., pop>  # if using chemformula
+        #   down
+        #   push
+        #     down
+        #     <push, push, xxx, right, xxx, pop, pop>  # if using xcolor
+        #     down
+        #     push
+        #       down (possibly multiple)
+        #       push  <=  here, v is the baseline position.
+        #         etc.
+        # (dviasm is useful to explore this structure.)
+        # Thus, we use the vertical position at the first time the stack depth
+        # reaches 3, while at least three "downs" have been executed (excluding
+        # those popped out (corresponding to the chemformula preamble)), as the
+        # baseline (the "down" count is necessary to handle xcolor).
+        down_stack = [0]
+        self._baseline_v = None
+        while True:
+            byte = self.file.read(1)[0]
+            self._dtable[byte](self, byte)
+            name = self._dtable[byte].__name__
+            if name == "_push":
+                down_stack.append(down_stack[-1])
+            elif name == "_pop":
+                down_stack.pop()
+            elif name == "_down":
+                down_stack[-1] += 1
+            if (self._baseline_v is None
+                    and len(getattr(self, "stack", [])) == 3
+                    and down_stack[-1] >= 4):
+                self._baseline_v = self.v
+            if byte == 140:                         # end of page
+                return True
+            if self.state is _dvistate.post_post:   # end of file
+                self.close()
+                return False
+
+    def _arg(self, nbytes, signed=False):
+        """
+        Read and return a big-endian integer *nbytes* long.
+        Signedness is determined by the *signed* keyword.
+        """
+        return int.from_bytes(self.file.read(nbytes), "big", signed=signed)
+
+    @_dispatch(min=0, max=127, state=_dvistate.inpage)
+    def _set_char_immediate(self, char):
+        self._put_char_real(char)
+        self.h += self.fonts[self.f]._width_of(char)
+
+    @_dispatch(min=128, max=131, state=_dvistate.inpage, args=('olen1',))
+    def _set_char(self, char):
+        self._put_char_real(char)
+        self.h += self.fonts[self.f]._width_of(char)
+
+    @_dispatch(132, state=_dvistate.inpage, args=('s4', 's4'))
+    def _set_rule(self, a, b):
+        self._put_rule_real(a, b)
+        self.h += b
+
+    @_dispatch(min=133, max=136, state=_dvistate.inpage, args=('olen1',))
+    def _put_char(self, char):
+        self._put_char_real(char)
+
+    def _put_char_real(self, char):
+        font = self.fonts[self.f]
+        if font._vf is None:
+            self.text.append(Text(self.h, self.v, font, char,
+                                  font._width_of(char)))
+        else:
+            scale = font._scale
+            for x, y, f, g, w in font._vf[char].text:
+                newf = DviFont(scale=_mul2012(scale, f._scale),
+                               tfm=f._tfm, texname=f.texname, vf=f._vf)
+                self.text.append(Text(self.h + _mul2012(x, scale),
+                                      self.v + _mul2012(y, scale),
+                                      newf, g, newf._width_of(g)))
+            self.boxes.extend([Box(self.h + _mul2012(x, scale),
+                                   self.v + _mul2012(y, scale),
+                                   _mul2012(a, scale), _mul2012(b, scale))
+                               for x, y, a, b in font._vf[char].boxes])
+
+    @_dispatch(137, state=_dvistate.inpage, args=('s4', 's4'))
+    def _put_rule(self, a, b):
+        self._put_rule_real(a, b)
+
+    def _put_rule_real(self, a, b):
+        if a > 0 and b > 0:
+            self.boxes.append(Box(self.h, self.v, a, b))
+
+    @_dispatch(138)
+    def _nop(self, _):
+        pass
+
+    @_dispatch(139, state=_dvistate.outer, args=('s4',)*11)
+    def _bop(self, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, p):
+        self.state = _dvistate.inpage
+        self.h, self.v, self.w, self.x, self.y, self.z = 0, 0, 0, 0, 0, 0
+        self.stack = []
+        self.text = []          # list of Text objects
+        self.boxes = []         # list of Box objects
+
+    @_dispatch(140, state=_dvistate.inpage)
+    def _eop(self, _):
+        self.state = _dvistate.outer
+        del self.h, self.v, self.w, self.x, self.y, self.z, self.stack
+
+    @_dispatch(141, state=_dvistate.inpage)
+    def _push(self, _):
+        self.stack.append((self.h, self.v, self.w, self.x, self.y, self.z))
+
+    @_dispatch(142, state=_dvistate.inpage)
+    def _pop(self, _):
+        self.h, self.v, self.w, self.x, self.y, self.z = self.stack.pop()
+
+    @_dispatch(min=143, max=146, state=_dvistate.inpage, args=('slen1',))
+    def _right(self, b):
+        self.h += b
+
+    @_dispatch(min=147, max=151, state=_dvistate.inpage, args=('slen',))
+    def _right_w(self, new_w):
+        if new_w is not None:
+            self.w = new_w
+        self.h += self.w
+
+    @_dispatch(min=152, max=156, state=_dvistate.inpage, args=('slen',))
+    def _right_x(self, new_x):
+        if new_x is not None:
+            self.x = new_x
+        self.h += self.x
+
+    @_dispatch(min=157, max=160, state=_dvistate.inpage, args=('slen1',))
+    def _down(self, a):
+        self.v += a
+
+    @_dispatch(min=161, max=165, state=_dvistate.inpage, args=('slen',))
+    def _down_y(self, new_y):
+        if new_y is not None:
+            self.y = new_y
+        self.v += self.y
+
+    @_dispatch(min=166, max=170, state=_dvistate.inpage, args=('slen',))
+    def _down_z(self, new_z):
+        if new_z is not None:
+            self.z = new_z
+        self.v += self.z
+
+    @_dispatch(min=171, max=234, state=_dvistate.inpage)
+    def _fnt_num_immediate(self, k):
+        self.f = k
+
+    @_dispatch(min=235, max=238, state=_dvistate.inpage, args=('olen1',))
+    def _fnt_num(self, new_f):
+        self.f = new_f
+
+    @_dispatch(min=239, max=242, args=('ulen1',))
+    def _xxx(self, datalen):
+        special = self.file.read(datalen)
+        _log.debug(
+            'Dvi._xxx: encountered special: %s',
+            ''.join([chr(ch) if 32 <= ch < 127 else '<%02x>' % ch
+                     for ch in special]))
+
+    @_dispatch(min=243, max=246, args=('olen1', 'u4', 'u4', 'u4', 'u1', 'u1'))
+    def _fnt_def(self, k, c, s, d, a, l):
+        self._fnt_def_real(k, c, s, d, a, l)
+
+    def _fnt_def_real(self, k, c, s, d, a, l):
+        n = self.file.read(a + l)
+        fontname = n[-l:].decode('ascii')
+        tfm = _tfmfile(fontname)
+        if c != 0 and tfm.checksum != 0 and c != tfm.checksum:
+            raise ValueError('tfm checksum mismatch: %s' % n)
+        try:
+            vf = _vffile(fontname)
+        except FileNotFoundError:
+            vf = None
+        self.fonts[k] = DviFont(scale=s, tfm=tfm, texname=n, vf=vf)
+
+    @_dispatch(247, state=_dvistate.pre, args=('u1', 'u4', 'u4', 'u4', 'u1'))
+    def _pre(self, i, num, den, mag, k):
+        self.file.read(k)  # comment in the dvi file
+        if i != 2:
+            raise ValueError("Unknown dvi format %d" % i)
+        if num != 25400000 or den != 7227 * 2**16:
+            raise ValueError("Nonstandard units in dvi file")
+            # meaning: TeX always uses those exact values, so it
+            # should be enough for us to support those
+            # (There are 72.27 pt to an inch so 7227 pt =
+            # 7227 * 2**16 sp to 100 in. The numerator is multiplied
+            # by 10^5 to get units of 10**-7 meters.)
+        if mag != 1000:
+            raise ValueError("Nonstandard magnification in dvi file")
+            # meaning: LaTeX seems to frown on setting \mag, so
+            # I think we can assume this is constant
+        self.state = _dvistate.outer
+
+    @_dispatch(248, state=_dvistate.outer)
+    def _post(self, _):
+        self.state = _dvistate.post_post
+        # TODO: actually read the postamble and finale?
+        # currently post_post just triggers closing the file
+
+    @_dispatch(249)
+    def _post_post(self, _):
+        raise NotImplementedError
+
+    @_dispatch(min=250, max=255)
+    def _malformed(self, offset):
+        raise ValueError(f"unknown command: byte {250 + offset}")
+
+
+class DviFont:
+    """
+    Encapsulation of a font that a DVI file can refer to.
+
+    This class holds a font's texname and size, supports comparison,
+    and knows the widths of glyphs in the same units as the AFM file.
+    There are also internal attributes (for use by dviread.py) that
+    are *not* used for comparison.
+
+    The size is in Adobe points (converted from TeX points).
+
+    Parameters
+    ----------
+    scale : float
+        Factor by which the font is scaled from its natural size.
+    tfm : Tfm
+        TeX font metrics for this font
+    texname : bytes
+       Name of the font as used internally by TeX and friends, as an ASCII
+       bytestring.  This is usually very different from any external font
+       names; `PsfontsMap` can be used to find the external name of the font.
+    vf : Vf
+       A TeX "virtual font" file, or None if this font is not virtual.
+
+    Attributes
+    ----------
+    texname : bytes
+    size : float
+       Size of the font in Adobe points, converted from the slightly
+       smaller TeX points.
+    widths : list
+       Widths of glyphs in glyph-space units, typically 1/1000ths of
+       the point size.
+
+    """
+    __slots__ = ('texname', 'size', 'widths', '_scale', '_vf', '_tfm')
+
+    def __init__(self, scale, tfm, texname, vf):
+        _api.check_isinstance(bytes, texname=texname)
+        self._scale = scale
+        self._tfm = tfm
+        self.texname = texname
+        self._vf = vf
+        self.size = scale * (72.0 / (72.27 * 2**16))
+        try:
+            nchars = max(tfm.width) + 1
+        except ValueError:
+            nchars = 0
+        self.widths = [(1000*tfm.width.get(char, 0)) >> 20
+                       for char in range(nchars)]
+
+    def __eq__(self, other):
+        return (type(self) is type(other)
+                and self.texname == other.texname and self.size == other.size)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __repr__(self):
+        return f"<{type(self).__name__}: {self.texname}>"
+
+    def _width_of(self, char):
+        """Width of char in dvi units."""
+        width = self._tfm.width.get(char, None)
+        if width is not None:
+            return _mul2012(width, self._scale)
+        _log.debug('No width for char %d in font %s.', char, self.texname)
+        return 0
+
+    def _height_depth_of(self, char):
+        """Height and depth of char in dvi units."""
+        result = []
+        for metric, name in ((self._tfm.height, "height"),
+                             (self._tfm.depth, "depth")):
+            value = metric.get(char, None)
+            if value is None:
+                _log.debug('No %s for char %d in font %s',
+                           name, char, self.texname)
+                result.append(0)
+            else:
+                result.append(_mul2012(value, self._scale))
+        # cmsyXX (symbols font) glyph 0 ("minus") has a nonzero descent
+        # so that TeX aligns equations properly
+        # (https://tex.stackexchange.com/q/526103/)
+        # but we actually care about the rasterization depth to align
+        # the dvipng-generated images.
+        if re.match(br'^cmsy\d+$', self.texname) and char == 0:
+            result[-1] = 0
+        return result
+
+
+class Vf(Dvi):
+    r"""
+    A virtual font (\*.vf file) containing subroutines for dvi files.
+
+    Parameters
+    ----------
+    filename : str or path-like
+
+    Notes
+    -----
+    The virtual font format is a derivative of dvi:
+    http://mirrors.ctan.org/info/knuth/virtual-fonts
+    This class reuses some of the machinery of `Dvi`
+    but replaces the `_read` loop and dispatch mechanism.
+
+    Examples
+    --------
+    ::
+
+        vf = Vf(filename)
+        glyph = vf[code]
+        glyph.text, glyph.boxes, glyph.width
+    """
+
+    def __init__(self, filename):
+        super().__init__(filename, 0)
+        try:
+            self._first_font = None
+            self._chars = {}
+            self._read()
+        finally:
+            self.close()
+
+    def __getitem__(self, code):
+        return self._chars[code]
+
+    def _read(self):
+        """
+        Read one page from the file. Return True if successful,
+        False if there were no more pages.
+        """
+        packet_char, packet_ends = None, None
+        packet_len, packet_width = None, None
+        while True:
+            byte = self.file.read(1)[0]
+            # If we are in a packet, execute the dvi instructions
+            if self.state is _dvistate.inpage:
+                byte_at = self.file.tell()-1
+                if byte_at == packet_ends:
+                    self._finalize_packet(packet_char, packet_width)
+                    packet_len, packet_char, packet_width = None, None, None
+                    # fall through to out-of-packet code
+                elif byte_at > packet_ends:
+                    raise ValueError("Packet length mismatch in vf file")
+                else:
+                    if byte in (139, 140) or byte >= 243:
+                        raise ValueError(
+                            "Inappropriate opcode %d in vf file" % byte)
+                    Dvi._dtable[byte](self, byte)
+                    continue
+
+            # We are outside a packet
+            if byte < 242:          # a short packet (length given by byte)
+                packet_len = byte
+                packet_char, packet_width = self._arg(1), self._arg(3)
+                packet_ends = self._init_packet(byte)
+                self.state = _dvistate.inpage
+            elif byte == 242:       # a long packet
+                packet_len, packet_char, packet_width = \
+                            [self._arg(x) for x in (4, 4, 4)]
+                self._init_packet(packet_len)
+            elif 243 <= byte <= 246:
+                k = self._arg(byte - 242, byte == 246)
+                c, s, d, a, l = [self._arg(x) for x in (4, 4, 4, 1, 1)]
+                self._fnt_def_real(k, c, s, d, a, l)
+                if self._first_font is None:
+                    self._first_font = k
+            elif byte == 247:       # preamble
+                i, k = self._arg(1), self._arg(1)
+                x = self.file.read(k)
+                cs, ds = self._arg(4), self._arg(4)
+                self._pre(i, x, cs, ds)
+            elif byte == 248:       # postamble (just some number of 248s)
+                break
+            else:
+                raise ValueError("Unknown vf opcode %d" % byte)
+
+    def _init_packet(self, pl):
+        if self.state != _dvistate.outer:
+            raise ValueError("Misplaced packet in vf file")
+        self.h, self.v, self.w, self.x, self.y, self.z = 0, 0, 0, 0, 0, 0
+        self.stack, self.text, self.boxes = [], [], []
+        self.f = self._first_font
+        return self.file.tell() + pl
+
+    def _finalize_packet(self, packet_char, packet_width):
+        self._chars[packet_char] = Page(
+            text=self.text, boxes=self.boxes, width=packet_width,
+            height=None, descent=None)
+        self.state = _dvistate.outer
+
+    def _pre(self, i, x, cs, ds):
+        if self.state is not _dvistate.pre:
+            raise ValueError("pre command in middle of vf file")
+        if i != 202:
+            raise ValueError("Unknown vf format %d" % i)
+        if len(x):
+            _log.debug('vf file comment: %s', x)
+        self.state = _dvistate.outer
+        # cs = checksum, ds = design size
+
+
+def _mul2012(num1, num2):
+    """Multiply two numbers in 20.12 fixed point format."""
+    # Separated into a function because >> has surprising precedence
+    return (num1*num2) >> 20
+
+
+class Tfm:
+    """
+    A TeX Font Metric file.
+
+    This implementation covers only the bare minimum needed by the Dvi class.
+
+    Parameters
+    ----------
+    filename : str or path-like
+
+    Attributes
+    ----------
+    checksum : int
+       Used for verifying against the dvi file.
+    design_size : int
+       Design size of the font (unknown units)
+    width, height, depth : dict
+       Dimensions of each character, need to be scaled by the factor
+       specified in the dvi file. These are dicts because indexing may
+       not start from 0.
+    """
+    __slots__ = ('checksum', 'design_size', 'width', 'height', 'depth')
+
+    def __init__(self, filename):
+        _log.debug('opening tfm file %s', filename)
+        with open(filename, 'rb') as file:
+            header1 = file.read(24)
+            lh, bc, ec, nw, nh, nd = struct.unpack('!6H', header1[2:14])
+            _log.debug('lh=%d, bc=%d, ec=%d, nw=%d, nh=%d, nd=%d',
+                       lh, bc, ec, nw, nh, nd)
+            header2 = file.read(4*lh)
+            self.checksum, self.design_size = struct.unpack('!2I', header2[:8])
+            # there is also encoding information etc.
+            char_info = file.read(4*(ec-bc+1))
+            widths = struct.unpack(f'!{nw}i', file.read(4*nw))
+            heights = struct.unpack(f'!{nh}i', file.read(4*nh))
+            depths = struct.unpack(f'!{nd}i', file.read(4*nd))
+        self.width, self.height, self.depth = {}, {}, {}
+        for idx, char in enumerate(range(bc, ec+1)):
+            byte0 = char_info[4*idx]
+            byte1 = char_info[4*idx+1]
+            self.width[char] = widths[byte0]
+            self.height[char] = heights[byte1 >> 4]
+            self.depth[char] = depths[byte1 & 0xf]
+
+
+PsFont = namedtuple('PsFont', 'texname psname effects encoding filename')
+
+
+class PsfontsMap:
+    """
+    A psfonts.map formatted file, mapping TeX fonts to PS fonts.
+
+    Parameters
+    ----------
+    filename : str or path-like
+
+    Notes
+    -----
+    For historical reasons, TeX knows many Type-1 fonts by different
+    names than the outside world. (For one thing, the names have to
+    fit in eight characters.) Also, TeX's native fonts are not Type-1
+    but Metafont, which is nontrivial to convert to PostScript except
+    as a bitmap. While high-quality conversions to Type-1 format exist
+    and are shipped with modern TeX distributions, we need to know
+    which Type-1 fonts are the counterparts of which native fonts. For
+    these reasons a mapping is needed from internal font names to font
+    file names.
+
+    A texmf tree typically includes mapping files called e.g.
+    :file:`psfonts.map`, :file:`pdftex.map`, or :file:`dvipdfm.map`.
+    The file :file:`psfonts.map` is used by :program:`dvips`,
+    :file:`pdftex.map` by :program:`pdfTeX`, and :file:`dvipdfm.map`
+    by :program:`dvipdfm`. :file:`psfonts.map` might avoid embedding
+    the 35 PostScript fonts (i.e., have no filename for them, as in
+    the Times-Bold example above), while the pdf-related files perhaps
+    only avoid the "Base 14" pdf fonts. But the user may have
+    configured these files differently.
+
+    Examples
+    --------
+    >>> map = PsfontsMap(find_tex_file('pdftex.map'))
+    >>> entry = map[b'ptmbo8r']
+    >>> entry.texname
+    b'ptmbo8r'
+    >>> entry.psname
+    b'Times-Bold'
+    >>> entry.encoding
+    '/usr/local/texlive/2008/texmf-dist/fonts/enc/dvips/base/8r.enc'
+    >>> entry.effects
+    {'slant': 0.16700000000000001}
+    >>> entry.filename
+    """
+    __slots__ = ('_filename', '_unparsed', '_parsed')
+
+    # Create a filename -> PsfontsMap cache, so that calling
+    # `PsfontsMap(filename)` with the same filename a second time immediately
+    # returns the same object.
+    @lru_cache
+    def __new__(cls, filename):
+        self = object.__new__(cls)
+        self._filename = os.fsdecode(filename)
+        # Some TeX distributions have enormous pdftex.map files which would
+        # take hundreds of milliseconds to parse, but it is easy enough to just
+        # store the unparsed lines (keyed by the first word, which is the
+        # texname) and parse them on-demand.
+        with open(filename, 'rb') as file:
+            self._unparsed = {}
+            for line in file:
+                tfmname = line.split(b' ', 1)[0]
+                self._unparsed.setdefault(tfmname, []).append(line)
+        self._parsed = {}
+        return self
+
+    def __getitem__(self, texname):
+        assert isinstance(texname, bytes)
+        if texname in self._unparsed:
+            for line in self._unparsed.pop(texname):
+                if self._parse_and_cache_line(line):
+                    break
+        try:
+            return self._parsed[texname]
+        except KeyError:
+            raise LookupError(
+                f"An associated PostScript font (required by Matplotlib) "
+                f"could not be found for TeX font {texname.decode('ascii')!r} "
+                f"in {self._filename!r}; this problem can often be solved by "
+                f"installing a suitable PostScript font package in your TeX "
+                f"package manager") from None
+
+    def _parse_and_cache_line(self, line):
+        """
+        Parse a line in the font mapping file.
+
+        The format is (partially) documented at
+        http://mirrors.ctan.org/systems/doc/pdftex/manual/pdftex-a.pdf
+        https://tug.org/texinfohtml/dvips.html#psfonts_002emap
+        Each line can have the following fields:
+
+        - tfmname (first, only required field),
+        - psname (defaults to tfmname, must come immediately after tfmname if
+          present),
+        - fontflags (integer, must come immediately after psname if present,
+          ignored by us),
+        - special (SlantFont and ExtendFont, only field that is double-quoted),
+        - fontfile, encodingfile (optional, prefixed by <, <<, or <[; << always
+          precedes a font, <[ always precedes an encoding, < can precede either
+          but then an encoding file must have extension .enc; < and << also
+          request different font subsetting behaviors but we ignore that; < can
+          be separated from the filename by whitespace).
+
+        special, fontfile, and encodingfile can appear in any order.
+        """
+        # If the map file specifies multiple encodings for a font, we
+        # follow pdfTeX in choosing the last one specified. Such
+        # entries are probably mistakes but they have occurred.
+        # https://tex.stackexchange.com/q/10826/
+
+        if not line or line.startswith((b" ", b"%", b"*", b";", b"#")):
+            return
+        tfmname = basename = special = encodingfile = fontfile = None
+        is_subsetted = is_t1 = is_truetype = False
+        matches = re.finditer(br'"([^"]*)(?:"|$)|(\S+)', line)
+        for match in matches:
+            quoted, unquoted = match.groups()
+            if unquoted:
+                if unquoted.startswith(b"<<"):  # font
+                    fontfile = unquoted[2:]
+                elif unquoted.startswith(b"<["):  # encoding
+                    encodingfile = unquoted[2:]
+                elif unquoted.startswith(b"<"):  # font or encoding
+                    word = (
+                        # <foo => foo
+                        unquoted[1:]
+                        # < by itself => read the next word
+                        or next(filter(None, next(matches).groups())))
+                    if word.endswith(b".enc"):
+                        encodingfile = word
+                    else:
+                        fontfile = word
+                        is_subsetted = True
+                elif tfmname is None:
+                    tfmname = unquoted
+                elif basename is None:
+                    basename = unquoted
+            elif quoted:
+                special = quoted
+        effects = {}
+        if special:
+            words = reversed(special.split())
+            for word in words:
+                if word == b"SlantFont":
+                    effects["slant"] = float(next(words))
+                elif word == b"ExtendFont":
+                    effects["extend"] = float(next(words))
+
+        # Verify some properties of the line that would cause it to be ignored
+        # otherwise.
+        if fontfile is not None:
+            if fontfile.endswith((b".ttf", b".ttc")):
+                is_truetype = True
+            elif not fontfile.endswith(b".otf"):
+                is_t1 = True
+        elif basename is not None:
+            is_t1 = True
+        if is_truetype and is_subsetted and encodingfile is None:
+            return
+        if not is_t1 and ("slant" in effects or "extend" in effects):
+            return
+        if abs(effects.get("slant", 0)) > 1:
+            return
+        if abs(effects.get("extend", 0)) > 2:
+            return
+
+        if basename is None:
+            basename = tfmname
+        if encodingfile is not None:
+            encodingfile = find_tex_file(encodingfile)
+        if fontfile is not None:
+            fontfile = find_tex_file(fontfile)
+        self._parsed[tfmname] = PsFont(
+            texname=tfmname, psname=basename, effects=effects,
+            encoding=encodingfile, filename=fontfile)
+        return True
+
+
+def _parse_enc(path):
+    r"""
+    Parse a \*.enc file referenced from a psfonts.map style file.
+
+    The format supported by this function is a tiny subset of PostScript.
+
+    Parameters
+    ----------
+    path : `os.PathLike`
+
+    Returns
+    -------
+    list
+        The nth entry of the list is the PostScript glyph name of the nth
+        glyph.
+    """
+    no_comments = re.sub("%.*", "", Path(path).read_text(encoding="ascii"))
+    array = re.search(r"(?s)\[(.*)\]", no_comments).group(1)
+    lines = [line for line in array.split() if line]
+    if all(line.startswith("/") for line in lines):
+        return [line[1:] for line in lines]
+    else:
+        raise ValueError(f"Failed to parse {path} as Postscript encoding")
+
+
+class _LuatexKpsewhich:
+    @lru_cache  # A singleton.
+    def __new__(cls):
+        self = object.__new__(cls)
+        self._proc = self._new_proc()
+        return self
+
+    def _new_proc(self):
+        return subprocess.Popen(
+            ["luatex", "--luaonly",
+             str(cbook._get_data_path("kpsewhich.lua"))],
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+
+    def search(self, filename):
+        if self._proc.poll() is not None:  # Dead, restart it.
+            self._proc = self._new_proc()
+        self._proc.stdin.write(os.fsencode(filename) + b"\n")
+        self._proc.stdin.flush()
+        out = self._proc.stdout.readline().rstrip()
+        return None if out == b"nil" else os.fsdecode(out)
+
+
+@lru_cache
+def find_tex_file(filename):
+    """
+    Find a file in the texmf tree using kpathsea_.
+
+    The kpathsea library, provided by most existing TeX distributions, both
+    on Unix-like systems and on Windows (MikTeX), is invoked via a long-lived
+    luatex process if luatex is installed, or via kpsewhich otherwise.
+
+    .. _kpathsea: https://www.tug.org/kpathsea/
+
+    Parameters
+    ----------
+    filename : str or path-like
+
+    Raises
+    ------
+    FileNotFoundError
+        If the file is not found.
+    """
+
+    # we expect these to always be ascii encoded, but use utf-8
+    # out of caution
+    if isinstance(filename, bytes):
+        filename = filename.decode('utf-8', errors='replace')
+
+    try:
+        lk = _LuatexKpsewhich()
+    except FileNotFoundError:
+        lk = None  # Fallback to directly calling kpsewhich, as below.
+
+    if lk:
+        path = lk.search(filename)
+    else:
+        if sys.platform == 'win32':
+            # On Windows only, kpathsea can use utf-8 for cmd args and output.
+            # The `command_line_encoding` environment variable is set to force
+            # it to always use utf-8 encoding.  See Matplotlib issue #11848.
+            kwargs = {'env': {**os.environ, 'command_line_encoding': 'utf-8'},
+                      'encoding': 'utf-8'}
+        else:  # On POSIX, run through the equivalent of os.fsdecode().
+            kwargs = {'encoding': sys.getfilesystemencoding(),
+                      'errors': 'surrogateescape'}
+
+        try:
+            path = (cbook._check_and_log_subprocess(['kpsewhich', filename],
+                                                    _log, **kwargs)
+                    .rstrip('\n'))
+        except (FileNotFoundError, RuntimeError):
+            path = None
+
+    if path:
+        return path
+    else:
+        raise FileNotFoundError(
+            f"Matplotlib's TeX implementation searched for a file named "
+            f"{filename!r} in your texmf tree, but could not find it")
+
+
+@lru_cache
+def _fontfile(cls, suffix, texname):
+    return cls(find_tex_file(texname + suffix))
+
+
+_tfmfile = partial(_fontfile, Tfm, ".tfm")
+_vffile = partial(_fontfile, Vf, ".vf")
+
+
+if __name__ == '__main__':
+    from argparse import ArgumentParser
+    import itertools
+
+    parser = ArgumentParser()
+    parser.add_argument("filename")
+    parser.add_argument("dpi", nargs="?", type=float, default=None)
+    args = parser.parse_args()
+    with Dvi(args.filename, args.dpi) as dvi:
+        fontmap = PsfontsMap(find_tex_file('pdftex.map'))
+        for page in dvi:
+            print(f"=== new page === "
+                  f"(w: {page.width}, h: {page.height}, d: {page.descent})")
+            for font, group in itertools.groupby(
+                    page.text, lambda text: text.font):
+                print(f"font: {font.texname.decode('latin-1')!r}\t"
+                      f"scale: {font._scale / 2 ** 20}")
+                print("x", "y", "glyph", "chr", "w", "(glyphs)", sep="\t")
+                for text in group:
+                    print(text.x, text.y, text.glyph,
+                          chr(text.glyph) if chr(text.glyph).isprintable()
+                          else ".",
+                          text.width, sep="\t")
+            if page.boxes:
+                print("x", "y", "h", "w", "", "(boxes)", sep="\t")
+                for box in page.boxes:
+                    print(box.x, box.y, box.height, box.width, sep="\t")

llava_next/lib/python3.10/site-packages/matplotlib/dviread.pyi

@@ -0,0 +1,90 @@
+from pathlib import Path
+import io
+import os
+from enum import Enum
+from collections.abc import Generator
+
+from typing import NamedTuple
+
+class _dvistate(Enum):
+    pre: int
+    outer: int
+    inpage: int
+    post_post: int
+    finale: int
+
+class Page(NamedTuple):
+    text: list[Text]
+    boxes: list[Box]
+    height: int
+    width: int
+    descent: int
+
+class Box(NamedTuple):
+    x: int
+    y: int
+    height: int
+    width: int
+
+class Text(NamedTuple):
+    x: int
+    y: int
+    font: DviFont
+    glyph: int
+    width: int
+    @property
+    def font_path(self) -> Path: ...
+    @property
+    def font_size(self) -> float: ...
+    @property
+    def font_effects(self) -> dict[str, float]: ...
+    @property
+    def glyph_name_or_index(self) -> int | str: ...
+
+class Dvi:
+    file: io.BufferedReader
+    dpi: float | None
+    fonts: dict[int, DviFont]
+    state: _dvistate
+    def __init__(self, filename: str | os.PathLike, dpi: float | None) -> None: ...
+    # Replace return with Self when py3.9 is dropped
+    def __enter__(self) -> Dvi: ...
+    def __exit__(self, etype, evalue, etrace) -> None: ...
+    def __iter__(self) -> Generator[Page, None, None]: ...
+    def close(self) -> None: ...
+
+class DviFont:
+    texname: bytes
+    size: float
+    widths: list[int]
+    def __init__(
+        self, scale: float, tfm: Tfm, texname: bytes, vf: Vf | None
+    ) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+
+class Vf(Dvi):
+    def __init__(self, filename: str | os.PathLike) -> None: ...
+    def __getitem__(self, code: int) -> Page: ...
+
+class Tfm:
+    checksum: int
+    design_size: int
+    width: dict[int, int]
+    height: dict[int, int]
+    depth: dict[int, int]
+    def __init__(self, filename: str | os.PathLike) -> None: ...
+
+class PsFont(NamedTuple):
+    texname: bytes
+    psname: bytes
+    effects: dict[str, float]
+    encoding: None | bytes
+    filename: str
+
+class PsfontsMap:
+    # Replace return with Self when py3.9 is dropped
+    def __new__(cls, filename: str | os.PathLike) -> PsfontsMap: ...
+    def __getitem__(self, texname: bytes) -> PsFont: ...
+
+def find_tex_file(filename: str | os.PathLike) -> str: ...

llava_next/lib/python3.10/site-packages/matplotlib/gridspec.py

@@ -0,0 +1,788 @@
+r"""
+:mod:`~matplotlib.gridspec` contains classes that help to layout multiple
+`~.axes.Axes` in a grid-like pattern within a figure.
+
+The `GridSpec` specifies the overall grid structure. Individual cells within
+the grid are referenced by `SubplotSpec`\s.
+
+Often, users need not access this module directly, and can use higher-level
+methods like `~.pyplot.subplots`, `~.pyplot.subplot_mosaic` and
+`~.Figure.subfigures`. See the tutorial :ref:`arranging_axes` for a guide.
+"""
+
+import copy
+import logging
+from numbers import Integral
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib import _api, _pylab_helpers, _tight_layout
+from matplotlib.transforms import Bbox
+
+_log = logging.getLogger(__name__)
+
+
+class GridSpecBase:
+    """
+    A base class of GridSpec that specifies the geometry of the grid
+    that a subplot will be placed.
+    """
+
+    def __init__(self, nrows, ncols, height_ratios=None, width_ratios=None):
+        """
+        Parameters
+        ----------
+        nrows, ncols : int
+            The number of rows and columns of the grid.
+        width_ratios : array-like of length *ncols*, optional
+            Defines the relative widths of the columns. Each column gets a
+            relative width of ``width_ratios[i] / sum(width_ratios)``.
+            If not given, all columns will have the same width.
+        height_ratios : array-like of length *nrows*, optional
+            Defines the relative heights of the rows. Each row gets a
+            relative height of ``height_ratios[i] / sum(height_ratios)``.
+            If not given, all rows will have the same height.
+        """
+        if not isinstance(nrows, Integral) or nrows <= 0:
+            raise ValueError(
+                f"Number of rows must be a positive integer, not {nrows!r}")
+        if not isinstance(ncols, Integral) or ncols <= 0:
+            raise ValueError(
+                f"Number of columns must be a positive integer, not {ncols!r}")
+        self._nrows, self._ncols = nrows, ncols
+        self.set_height_ratios(height_ratios)
+        self.set_width_ratios(width_ratios)
+
+    def __repr__(self):
+        height_arg = (f', height_ratios={self._row_height_ratios!r}'
+                      if len(set(self._row_height_ratios)) != 1 else '')
+        width_arg = (f', width_ratios={self._col_width_ratios!r}'
+                     if len(set(self._col_width_ratios)) != 1 else '')
+        return '{clsname}({nrows}, {ncols}{optionals})'.format(
+            clsname=self.__class__.__name__,
+            nrows=self._nrows,
+            ncols=self._ncols,
+            optionals=height_arg + width_arg,
+            )
+
+    nrows = property(lambda self: self._nrows,
+                     doc="The number of rows in the grid.")
+    ncols = property(lambda self: self._ncols,
+                     doc="The number of columns in the grid.")
+
+    def get_geometry(self):
+        """
+        Return a tuple containing the number of rows and columns in the grid.
+        """
+        return self._nrows, self._ncols
+
+    def get_subplot_params(self, figure=None):
+        # Must be implemented in subclasses
+        pass
+
+    def new_subplotspec(self, loc, rowspan=1, colspan=1):
+        """
+        Create and return a `.SubplotSpec` instance.
+
+        Parameters
+        ----------
+        loc : (int, int)
+            The position of the subplot in the grid as
+            ``(row_index, column_index)``.
+        rowspan, colspan : int, default: 1
+            The number of rows and columns the subplot should span in the grid.
+        """
+        loc1, loc2 = loc
+        subplotspec = self[loc1:loc1+rowspan, loc2:loc2+colspan]
+        return subplotspec
+
+    def set_width_ratios(self, width_ratios):
+        """
+        Set the relative widths of the columns.
+
+        *width_ratios* must be of length *ncols*. Each column gets a relative
+        width of ``width_ratios[i] / sum(width_ratios)``.
+        """
+        if width_ratios is None:
+            width_ratios = [1] * self._ncols
+        elif len(width_ratios) != self._ncols:
+            raise ValueError('Expected the given number of width ratios to '
+                             'match the number of columns of the grid')
+        self._col_width_ratios = width_ratios
+
+    def get_width_ratios(self):
+        """
+        Return the width ratios.
+
+        This is *None* if no width ratios have been set explicitly.
+        """
+        return self._col_width_ratios
+
+    def set_height_ratios(self, height_ratios):
+        """
+        Set the relative heights of the rows.
+
+        *height_ratios* must be of length *nrows*. Each row gets a relative
+        height of ``height_ratios[i] / sum(height_ratios)``.
+        """
+        if height_ratios is None:
+            height_ratios = [1] * self._nrows
+        elif len(height_ratios) != self._nrows:
+            raise ValueError('Expected the given number of height ratios to '
+                             'match the number of rows of the grid')
+        self._row_height_ratios = height_ratios
+
+    def get_height_ratios(self):
+        """
+        Return the height ratios.
+
+        This is *None* if no height ratios have been set explicitly.
+        """
+        return self._row_height_ratios
+
+    def get_grid_positions(self, fig):
+        """
+        Return the positions of the grid cells in figure coordinates.
+
+        Parameters
+        ----------
+        fig : `~matplotlib.figure.Figure`
+            The figure the grid should be applied to. The subplot parameters
+            (margins and spacing between subplots) are taken from *fig*.
+
+        Returns
+        -------
+        bottoms, tops, lefts, rights : array
+            The bottom, top, left, right positions of the grid cells in
+            figure coordinates.
+        """
+        nrows, ncols = self.get_geometry()
+        subplot_params = self.get_subplot_params(fig)
+        left = subplot_params.left
+        right = subplot_params.right
+        bottom = subplot_params.bottom
+        top = subplot_params.top
+        wspace = subplot_params.wspace
+        hspace = subplot_params.hspace
+        tot_width = right - left
+        tot_height = top - bottom
+
+        # calculate accumulated heights of columns
+        cell_h = tot_height / (nrows + hspace*(nrows-1))
+        sep_h = hspace * cell_h
+        norm = cell_h * nrows / sum(self._row_height_ratios)
+        cell_heights = [r * norm for r in self._row_height_ratios]
+        sep_heights = [0] + ([sep_h] * (nrows-1))
+        cell_hs = np.cumsum(np.column_stack([sep_heights, cell_heights]).flat)
+
+        # calculate accumulated widths of rows
+        cell_w = tot_width / (ncols + wspace*(ncols-1))
+        sep_w = wspace * cell_w
+        norm = cell_w * ncols / sum(self._col_width_ratios)
+        cell_widths = [r * norm for r in self._col_width_ratios]
+        sep_widths = [0] + ([sep_w] * (ncols-1))
+        cell_ws = np.cumsum(np.column_stack([sep_widths, cell_widths]).flat)
+
+        fig_tops, fig_bottoms = (top - cell_hs).reshape((-1, 2)).T
+        fig_lefts, fig_rights = (left + cell_ws).reshape((-1, 2)).T
+        return fig_bottoms, fig_tops, fig_lefts, fig_rights
+
+    @staticmethod
+    def _check_gridspec_exists(figure, nrows, ncols):
+        """
+        Check if the figure already has a gridspec with these dimensions,
+        or create a new one
+        """
+        for ax in figure.get_axes():
+            gs = ax.get_gridspec()
+            if gs is not None:
+                if hasattr(gs, 'get_topmost_subplotspec'):
+                    # This is needed for colorbar gridspec layouts.
+                    # This is probably OK because this whole logic tree
+                    # is for when the user is doing simple things with the
+                    # add_subplot command.  For complicated layouts
+                    # like subgridspecs the proper gridspec is passed in...
+                    gs = gs.get_topmost_subplotspec().get_gridspec()
+                if gs.get_geometry() == (nrows, ncols):
+                    return gs
+        # else gridspec not found:
+        return GridSpec(nrows, ncols, figure=figure)
+
+    def __getitem__(self, key):
+        """Create and return a `.SubplotSpec` instance."""
+        nrows, ncols = self.get_geometry()
+
+        def _normalize(key, size, axis):  # Includes last index.
+            orig_key = key
+            if isinstance(key, slice):
+                start, stop, _ = key.indices(size)
+                if stop > start:
+                    return start, stop - 1
+                raise IndexError("GridSpec slice would result in no space "
+                                 "allocated for subplot")
+            else:
+                if key < 0:
+                    key = key + size
+                if 0 <= key < size:
+                    return key, key
+                elif axis is not None:
+                    raise IndexError(f"index {orig_key} is out of bounds for "
+                                     f"axis {axis} with size {size}")
+                else:  # flat index
+                    raise IndexError(f"index {orig_key} is out of bounds for "
+                                     f"GridSpec with size {size}")
+
+        if isinstance(key, tuple):
+            try:
+                k1, k2 = key
+            except ValueError as err:
+                raise ValueError("Unrecognized subplot spec") from err
+            num1, num2 = np.ravel_multi_index(
+                [_normalize(k1, nrows, 0), _normalize(k2, ncols, 1)],
+                (nrows, ncols))
+        else:  # Single key
+            num1, num2 = _normalize(key, nrows * ncols, None)
+
+        return SubplotSpec(self, num1, num2)
+
+    def subplots(self, *, sharex=False, sharey=False, squeeze=True,
+                 subplot_kw=None):
+        """
+        Add all subplots specified by this `GridSpec` to its parent figure.
+
+        See `.Figure.subplots` for detailed documentation.
+        """
+
+        figure = self.figure
+
+        if figure is None:
+            raise ValueError("GridSpec.subplots() only works for GridSpecs "
+                             "created with a parent figure")
+
+        if not isinstance(sharex, str):
+            sharex = "all" if sharex else "none"
+        if not isinstance(sharey, str):
+            sharey = "all" if sharey else "none"
+
+        _api.check_in_list(["all", "row", "col", "none", False, True],
+                           sharex=sharex, sharey=sharey)
+        if subplot_kw is None:
+            subplot_kw = {}
+        # don't mutate kwargs passed by user...
+        subplot_kw = subplot_kw.copy()
+
+        # Create array to hold all Axes.
+        axarr = np.empty((self._nrows, self._ncols), dtype=object)
+        for row in range(self._nrows):
+            for col in range(self._ncols):
+                shared_with = {"none": None, "all": axarr[0, 0],
+                               "row": axarr[row, 0], "col": axarr[0, col]}
+                subplot_kw["sharex"] = shared_with[sharex]
+                subplot_kw["sharey"] = shared_with[sharey]
+                axarr[row, col] = figure.add_subplot(
+                    self[row, col], **subplot_kw)
+
+        # turn off redundant tick labeling
+        if sharex in ["col", "all"]:
+            for ax in axarr.flat:
+                ax._label_outer_xaxis(skip_non_rectangular_axes=True)
+        if sharey in ["row", "all"]:
+            for ax in axarr.flat:
+                ax._label_outer_yaxis(skip_non_rectangular_axes=True)
+
+        if squeeze:
+            # Discarding unneeded dimensions that equal 1.  If we only have one
+            # subplot, just return it instead of a 1-element array.
+            return axarr.item() if axarr.size == 1 else axarr.squeeze()
+        else:
+            # Returned axis array will be always 2-d, even if nrows=ncols=1.
+            return axarr
+
+
+class GridSpec(GridSpecBase):
+    """
+    A grid layout to place subplots within a figure.
+
+    The location of the grid cells is determined in a similar way to
+    `.SubplotParams` using *left*, *right*, *top*, *bottom*, *wspace*
+    and *hspace*.
+
+    Indexing a GridSpec instance returns a `.SubplotSpec`.
+    """
+    def __init__(self, nrows, ncols, figure=None,
+                 left=None, bottom=None, right=None, top=None,
+                 wspace=None, hspace=None,
+                 width_ratios=None, height_ratios=None):
+        """
+        Parameters
+        ----------
+        nrows, ncols : int
+            The number of rows and columns of the grid.
+
+        figure : `.Figure`, optional
+            Only used for constrained layout to create a proper layoutgrid.
+
+        left, right, top, bottom : float, optional
+            Extent of the subplots as a fraction of figure width or height.
+            Left cannot be larger than right, and bottom cannot be larger than
+            top. If not given, the values will be inferred from a figure or
+            rcParams at draw time. See also `GridSpec.get_subplot_params`.
+
+        wspace : float, optional
+            The amount of width reserved for space between subplots,
+            expressed as a fraction of the average axis width.
+            If not given, the values will be inferred from a figure or
+            rcParams when necessary. See also `GridSpec.get_subplot_params`.
+
+        hspace : float, optional
+            The amount of height reserved for space between subplots,
+            expressed as a fraction of the average axis height.
+            If not given, the values will be inferred from a figure or
+            rcParams when necessary. See also `GridSpec.get_subplot_params`.
+
+        width_ratios : array-like of length *ncols*, optional
+            Defines the relative widths of the columns. Each column gets a
+            relative width of ``width_ratios[i] / sum(width_ratios)``.
+            If not given, all columns will have the same width.
+
+        height_ratios : array-like of length *nrows*, optional
+            Defines the relative heights of the rows. Each row gets a
+            relative height of ``height_ratios[i] / sum(height_ratios)``.
+            If not given, all rows will have the same height.
+
+        """
+        self.left = left
+        self.bottom = bottom
+        self.right = right
+        self.top = top
+        self.wspace = wspace
+        self.hspace = hspace
+        self.figure = figure
+
+        super().__init__(nrows, ncols,
+                         width_ratios=width_ratios,
+                         height_ratios=height_ratios)
+
+    _AllowedKeys = ["left", "bottom", "right", "top", "wspace", "hspace"]
+
+    def update(self, **kwargs):
+        """
+        Update the subplot parameters of the grid.
+
+        Parameters that are not explicitly given are not changed. Setting a
+        parameter to *None* resets it to :rc:`figure.subplot.*`.
+
+        Parameters
+        ----------
+        left, right, top, bottom : float or None, optional
+            Extent of the subplots as a fraction of figure width or height.
+        wspace, hspace : float, optional
+            Spacing between the subplots as a fraction of the average subplot
+            width / height.
+        """
+        for k, v in kwargs.items():
+            if k in self._AllowedKeys:
+                setattr(self, k, v)
+            else:
+                raise AttributeError(f"{k} is an unknown keyword")
+        for figmanager in _pylab_helpers.Gcf.figs.values():
+            for ax in figmanager.canvas.figure.axes:
+                if ax.get_subplotspec() is not None:
+                    ss = ax.get_subplotspec().get_topmost_subplotspec()
+                    if ss.get_gridspec() == self:
+                        ax._set_position(
+                            ax.get_subplotspec().get_position(ax.figure))
+
+    def get_subplot_params(self, figure=None):
+        """
+        Return the `.SubplotParams` for the GridSpec.
+
+        In order of precedence the values are taken from
+
+        - non-*None* attributes of the GridSpec
+        - the provided *figure*
+        - :rc:`figure.subplot.*`
+
+        Note that the ``figure`` attribute of the GridSpec is always ignored.
+        """
+        if figure is None:
+            kw = {k: mpl.rcParams["figure.subplot."+k]
+                  for k in self._AllowedKeys}
+            subplotpars = SubplotParams(**kw)
+        else:
+            subplotpars = copy.copy(figure.subplotpars)
+
+        subplotpars.update(**{k: getattr(self, k) for k in self._AllowedKeys})
+
+        return subplotpars
+
+    def locally_modified_subplot_params(self):
+        """
+        Return a list of the names of the subplot parameters explicitly set
+        in the GridSpec.
+
+        This is a subset of the attributes of `.SubplotParams`.
+        """
+        return [k for k in self._AllowedKeys if getattr(self, k)]
+
+    def tight_layout(self, figure, renderer=None,
+                     pad=1.08, h_pad=None, w_pad=None, rect=None):
+        """
+        Adjust subplot parameters to give specified padding.
+
+        Parameters
+        ----------
+        figure : `.Figure`
+            The figure.
+        renderer :  `.RendererBase` subclass, optional
+            The renderer to be used.
+        pad : float
+            Padding between the figure edge and the edges of subplots, as a
+            fraction of the font-size.
+        h_pad, w_pad : float, optional
+            Padding (height/width) between edges of adjacent subplots.
+            Defaults to *pad*.
+        rect : tuple (left, bottom, right, top), default: None
+            (left, bottom, right, top) rectangle in normalized figure
+            coordinates that the whole subplots area (including labels) will
+            fit into. Default (None) is the whole figure.
+        """
+        if renderer is None:
+            renderer = figure._get_renderer()
+        kwargs = _tight_layout.get_tight_layout_figure(
+            figure, figure.axes,
+            _tight_layout.get_subplotspec_list(figure.axes, grid_spec=self),
+            renderer, pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect)
+        if kwargs:
+            self.update(**kwargs)
+
+
+class GridSpecFromSubplotSpec(GridSpecBase):
+    """
+    GridSpec whose subplot layout parameters are inherited from the
+    location specified by a given SubplotSpec.
+    """
+    def __init__(self, nrows, ncols,
+                 subplot_spec,
+                 wspace=None, hspace=None,
+                 height_ratios=None, width_ratios=None):
+        """
+        Parameters
+        ----------
+        nrows, ncols : int
+            Number of rows and number of columns of the grid.
+        subplot_spec : SubplotSpec
+            Spec from which the layout parameters are inherited.
+        wspace, hspace : float, optional
+            See `GridSpec` for more details. If not specified default values
+            (from the figure or rcParams) are used.
+        height_ratios : array-like of length *nrows*, optional
+            See `GridSpecBase` for details.
+        width_ratios : array-like of length *ncols*, optional
+            See `GridSpecBase` for details.
+        """
+        self._wspace = wspace
+        self._hspace = hspace
+        if isinstance(subplot_spec, SubplotSpec):
+            self._subplot_spec = subplot_spec
+        else:
+            raise TypeError(
+                            "subplot_spec must be type SubplotSpec, "
+                            "usually from GridSpec, or axes.get_subplotspec.")
+        self.figure = self._subplot_spec.get_gridspec().figure
+        super().__init__(nrows, ncols,
+                         width_ratios=width_ratios,
+                         height_ratios=height_ratios)
+
+    def get_subplot_params(self, figure=None):
+        """Return a dictionary of subplot layout parameters."""
+        hspace = (self._hspace if self._hspace is not None
+                  else figure.subplotpars.hspace if figure is not None
+                  else mpl.rcParams["figure.subplot.hspace"])
+        wspace = (self._wspace if self._wspace is not None
+                  else figure.subplotpars.wspace if figure is not None
+                  else mpl.rcParams["figure.subplot.wspace"])
+
+        figbox = self._subplot_spec.get_position(figure)
+        left, bottom, right, top = figbox.extents
+
+        return SubplotParams(left=left, right=right,
+                             bottom=bottom, top=top,
+                             wspace=wspace, hspace=hspace)
+
+    def get_topmost_subplotspec(self):
+        """
+        Return the topmost `.SubplotSpec` instance associated with the subplot.
+        """
+        return self._subplot_spec.get_topmost_subplotspec()
+
+
+class SubplotSpec:
+    """
+    The location of a subplot in a `GridSpec`.
+
+    .. note::
+
+        Likely, you will never instantiate a `SubplotSpec` yourself. Instead,
+        you will typically obtain one from a `GridSpec` using item-access.
+
+    Parameters
+    ----------
+    gridspec : `~matplotlib.gridspec.GridSpec`
+        The GridSpec, which the subplot is referencing.
+    num1, num2 : int
+        The subplot will occupy the *num1*-th cell of the given
+        *gridspec*.  If *num2* is provided, the subplot will span between
+        *num1*-th cell and *num2*-th cell **inclusive**.
+
+        The index starts from 0.
+    """
+    def __init__(self, gridspec, num1, num2=None):
+        self._gridspec = gridspec
+        self.num1 = num1
+        self.num2 = num2
+
+    def __repr__(self):
+        return (f"{self.get_gridspec()}["
+                f"{self.rowspan.start}:{self.rowspan.stop}, "
+                f"{self.colspan.start}:{self.colspan.stop}]")
+
+    @staticmethod
+    def _from_subplot_args(figure, args):
+        """
+        Construct a `.SubplotSpec` from a parent `.Figure` and either
+
+        - a `.SubplotSpec` -- returned as is;
+        - one or three numbers -- a MATLAB-style subplot specifier.
+        """
+        if len(args) == 1:
+            arg, = args
+            if isinstance(arg, SubplotSpec):
+                return arg
+            elif not isinstance(arg, Integral):
+                raise ValueError(
+                    f"Single argument to subplot must be a three-digit "
+                    f"integer, not {arg!r}")
+            try:
+                rows, cols, num = map(int, str(arg))
+            except ValueError:
+                raise ValueError(
+                    f"Single argument to subplot must be a three-digit "
+                    f"integer, not {arg!r}") from None
+        elif len(args) == 3:
+            rows, cols, num = args
+        else:
+            raise _api.nargs_error("subplot", takes="1 or 3", given=len(args))
+
+        gs = GridSpec._check_gridspec_exists(figure, rows, cols)
+        if gs is None:
+            gs = GridSpec(rows, cols, figure=figure)
+        if isinstance(num, tuple) and len(num) == 2:
+            if not all(isinstance(n, Integral) for n in num):
+                raise ValueError(
+                    f"Subplot specifier tuple must contain integers, not {num}"
+                )
+            i, j = num
+        else:
+            if not isinstance(num, Integral) or num < 1 or num > rows*cols:
+                raise ValueError(
+                    f"num must be an integer with 1 <= num <= {rows*cols}, "
+                    f"not {num!r}"
+                )
+            i = j = num
+        return gs[i-1:j]
+
+    # num2 is a property only to handle the case where it is None and someone
+    # mutates num1.
+
+    @property
+    def num2(self):
+        return self.num1 if self._num2 is None else self._num2
+
+    @num2.setter
+    def num2(self, value):
+        self._num2 = value
+
+    def get_gridspec(self):
+        return self._gridspec
+
+    def get_geometry(self):
+        """
+        Return the subplot geometry as tuple ``(n_rows, n_cols, start, stop)``.
+
+        The indices *start* and *stop* define the range of the subplot within
+        the `GridSpec`. *stop* is inclusive (i.e. for a single cell
+        ``start == stop``).
+        """
+        rows, cols = self.get_gridspec().get_geometry()
+        return rows, cols, self.num1, self.num2
+
+    @property
+    def rowspan(self):
+        """The rows spanned by this subplot, as a `range` object."""
+        ncols = self.get_gridspec().ncols
+        return range(self.num1 // ncols, self.num2 // ncols + 1)
+
+    @property
+    def colspan(self):
+        """The columns spanned by this subplot, as a `range` object."""
+        ncols = self.get_gridspec().ncols
+        # We explicitly support num2 referring to a column on num1's *left*, so
+        # we must sort the column indices here so that the range makes sense.
+        c1, c2 = sorted([self.num1 % ncols, self.num2 % ncols])
+        return range(c1, c2 + 1)
+
+    def is_first_row(self):
+        return self.rowspan.start == 0
+
+    def is_last_row(self):
+        return self.rowspan.stop == self.get_gridspec().nrows
+
+    def is_first_col(self):
+        return self.colspan.start == 0
+
+    def is_last_col(self):
+        return self.colspan.stop == self.get_gridspec().ncols
+
+    def get_position(self, figure):
+        """
+        Update the subplot position from ``figure.subplotpars``.
+        """
+        gridspec = self.get_gridspec()
+        nrows, ncols = gridspec.get_geometry()
+        rows, cols = np.unravel_index([self.num1, self.num2], (nrows, ncols))
+        fig_bottoms, fig_tops, fig_lefts, fig_rights = \
+            gridspec.get_grid_positions(figure)
+
+        fig_bottom = fig_bottoms[rows].min()
+        fig_top = fig_tops[rows].max()
+        fig_left = fig_lefts[cols].min()
+        fig_right = fig_rights[cols].max()
+        return Bbox.from_extents(fig_left, fig_bottom, fig_right, fig_top)
+
+    def get_topmost_subplotspec(self):
+        """
+        Return the topmost `SubplotSpec` instance associated with the subplot.
+        """
+        gridspec = self.get_gridspec()
+        if hasattr(gridspec, "get_topmost_subplotspec"):
+            return gridspec.get_topmost_subplotspec()
+        else:
+            return self
+
+    def __eq__(self, other):
+        """
+        Two SubplotSpecs are considered equal if they refer to the same
+        position(s) in the same `GridSpec`.
+        """
+        # other may not even have the attributes we are checking.
+        return ((self._gridspec, self.num1, self.num2)
+                == (getattr(other, "_gridspec", object()),
+                    getattr(other, "num1", object()),
+                    getattr(other, "num2", object())))
+
+    def __hash__(self):
+        return hash((self._gridspec, self.num1, self.num2))
+
+    def subgridspec(self, nrows, ncols, **kwargs):
+        """
+        Create a GridSpec within this subplot.
+
+        The created `.GridSpecFromSubplotSpec` will have this `SubplotSpec` as
+        a parent.
+
+        Parameters
+        ----------
+        nrows : int
+            Number of rows in grid.
+
+        ncols : int
+            Number of columns in grid.
+
+        Returns
+        -------
+        `.GridSpecFromSubplotSpec`
+
+        Other Parameters
+        ----------------
+        **kwargs
+            All other parameters are passed to `.GridSpecFromSubplotSpec`.
+
+        See Also
+        --------
+        matplotlib.pyplot.subplots
+
+        Examples
+        --------
+        Adding three subplots in the space occupied by a single subplot::
+
+            fig = plt.figure()
+            gs0 = fig.add_gridspec(3, 1)
+            ax1 = fig.add_subplot(gs0[0])
+            ax2 = fig.add_subplot(gs0[1])
+            gssub = gs0[2].subgridspec(1, 3)
+            for i in range(3):
+                fig.add_subplot(gssub[0, i])
+        """
+        return GridSpecFromSubplotSpec(nrows, ncols, self, **kwargs)
+
+
+class SubplotParams:
+    """
+    Parameters defining the positioning of a subplots grid in a figure.
+    """
+
+    def __init__(self, left=None, bottom=None, right=None, top=None,
+                 wspace=None, hspace=None):
+        """
+        Defaults are given by :rc:`figure.subplot.[name]`.
+
+        Parameters
+        ----------
+        left : float
+            The position of the left edge of the subplots,
+            as a fraction of the figure width.
+        right : float
+            The position of the right edge of the subplots,
+            as a fraction of the figure width.
+        bottom : float
+            The position of the bottom edge of the subplots,
+            as a fraction of the figure height.
+        top : float
+            The position of the top edge of the subplots,
+            as a fraction of the figure height.
+        wspace : float
+            The width of the padding between subplots,
+            as a fraction of the average Axes width.
+        hspace : float
+            The height of the padding between subplots,
+            as a fraction of the average Axes height.
+        """
+        for key in ["left", "bottom", "right", "top", "wspace", "hspace"]:
+            setattr(self, key, mpl.rcParams[f"figure.subplot.{key}"])
+        self.update(left, bottom, right, top, wspace, hspace)
+
+    def update(self, left=None, bottom=None, right=None, top=None,
+               wspace=None, hspace=None):
+        """
+        Update the dimensions of the passed parameters. *None* means unchanged.
+        """
+        if ((left if left is not None else self.left)
+                >= (right if right is not None else self.right)):
+            raise ValueError('left cannot be >= right')
+        if ((bottom if bottom is not None else self.bottom)
+                >= (top if top is not None else self.top)):
+            raise ValueError('bottom cannot be >= top')
+        if left is not None:
+            self.left = left
+        if right is not None:
+            self.right = right
+        if bottom is not None:
+            self.bottom = bottom
+        if top is not None:
+            self.top = top
+        if wspace is not None:
+            self.wspace = wspace
+        if hspace is not None:
+            self.hspace = hspace

llava_next/lib/python3.10/site-packages/matplotlib/legend.py

@@ -0,0 +1,1385 @@
+"""
+The legend module defines the Legend class, which is responsible for
+drawing legends associated with Axes and/or figures.
+
+.. important::
+
+    It is unlikely that you would ever create a Legend instance manually.
+    Most users would normally create a legend via the `~.Axes.legend`
+    function. For more details on legends there is also a :ref:`legend guide
+    <legend_guide>`.
+
+The `Legend` class is a container of legend handles and legend texts.
+
+The legend handler map specifies how to create legend handles from artists
+(lines, patches, etc.) in the Axes or figures. Default legend handlers are
+defined in the :mod:`~matplotlib.legend_handler` module. While not all artist
+types are covered by the default legend handlers, custom legend handlers can be
+defined to support arbitrary objects.
+
+See the :ref`<legend_guide>` for more
+information.
+"""
+
+import itertools
+import logging
+import numbers
+import time
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib import _api, _docstring, cbook, colors, offsetbox
+from matplotlib.artist import Artist, allow_rasterization
+from matplotlib.cbook import silent_list
+from matplotlib.font_manager import FontProperties
+from matplotlib.lines import Line2D
+from matplotlib.patches import (Patch, Rectangle, Shadow, FancyBboxPatch,
+                                StepPatch)
+from matplotlib.collections import (
+    Collection, CircleCollection, LineCollection, PathCollection,
+    PolyCollection, RegularPolyCollection)
+from matplotlib.text import Text
+from matplotlib.transforms import Bbox, BboxBase, TransformedBbox
+from matplotlib.transforms import BboxTransformTo, BboxTransformFrom
+from matplotlib.offsetbox import (
+    AnchoredOffsetbox, DraggableOffsetBox,
+    HPacker, VPacker,
+    DrawingArea, TextArea,
+)
+from matplotlib.container import ErrorbarContainer, BarContainer, StemContainer
+from . import legend_handler
+
+
+class DraggableLegend(DraggableOffsetBox):
+    def __init__(self, legend, use_blit=False, update="loc"):
+        """
+        Wrapper around a `.Legend` to support mouse dragging.
+
+        Parameters
+        ----------
+        legend : `.Legend`
+            The `.Legend` instance to wrap.
+        use_blit : bool, optional
+            Use blitting for faster image composition. For details see
+            :ref:`func-animation`.
+        update : {'loc', 'bbox'}, optional
+            If "loc", update the *loc* parameter of the legend upon finalizing.
+            If "bbox", update the *bbox_to_anchor* parameter.
+        """
+        self.legend = legend
+
+        _api.check_in_list(["loc", "bbox"], update=update)
+        self._update = update
+
+        super().__init__(legend, legend._legend_box, use_blit=use_blit)
+
+    def finalize_offset(self):
+        if self._update == "loc":
+            self._update_loc(self.get_loc_in_canvas())
+        elif self._update == "bbox":
+            self._update_bbox_to_anchor(self.get_loc_in_canvas())
+
+    def _update_loc(self, loc_in_canvas):
+        bbox = self.legend.get_bbox_to_anchor()
+        # if bbox has zero width or height, the transformation is
+        # ill-defined. Fall back to the default bbox_to_anchor.
+        if bbox.width == 0 or bbox.height == 0:
+            self.legend.set_bbox_to_anchor(None)
+            bbox = self.legend.get_bbox_to_anchor()
+        _bbox_transform = BboxTransformFrom(bbox)
+        self.legend._loc = tuple(_bbox_transform.transform(loc_in_canvas))
+
+    def _update_bbox_to_anchor(self, loc_in_canvas):
+        loc_in_bbox = self.legend.axes.transAxes.transform(loc_in_canvas)
+        self.legend.set_bbox_to_anchor(loc_in_bbox)
+
+
+_legend_kw_doc_base = """
+bbox_to_anchor : `.BboxBase`, 2-tuple, or 4-tuple of floats
+    Box that is used to position the legend in conjunction with *loc*.
+    Defaults to `axes.bbox` (if called as a method to `.Axes.legend`) or
+    `figure.bbox` (if `.Figure.legend`).  This argument allows arbitrary
+    placement of the legend.
+
+    Bbox coordinates are interpreted in the coordinate system given by
+    *bbox_transform*, with the default transform
+    Axes or Figure coordinates, depending on which ``legend`` is called.
+
+    If a 4-tuple or `.BboxBase` is given, then it specifies the bbox
+    ``(x, y, width, height)`` that the legend is placed in.
+    To put the legend in the best location in the bottom right
+    quadrant of the Axes (or figure)::
+
+        loc='best', bbox_to_anchor=(0.5, 0., 0.5, 0.5)
+
+    A 2-tuple ``(x, y)`` places the corner of the legend specified by *loc* at
+    x, y.  For example, to put the legend's upper right-hand corner in the
+    center of the Axes (or figure) the following keywords can be used::
+
+        loc='upper right', bbox_to_anchor=(0.5, 0.5)
+
+ncols : int, default: 1
+    The number of columns that the legend has.
+
+    For backward compatibility, the spelling *ncol* is also supported
+    but it is discouraged. If both are given, *ncols* takes precedence.
+
+prop : None or `~matplotlib.font_manager.FontProperties` or dict
+    The font properties of the legend. If None (default), the current
+    :data:`matplotlib.rcParams` will be used.
+
+fontsize : int or {'xx-small', 'x-small', 'small', 'medium', 'large', \
+'x-large', 'xx-large'}
+    The font size of the legend. If the value is numeric the size will be the
+    absolute font size in points. String values are relative to the current
+    default font size. This argument is only used if *prop* is not specified.
+
+labelcolor : str or list, default: :rc:`legend.labelcolor`
+    The color of the text in the legend. Either a valid color string
+    (for example, 'red'), or a list of color strings. The labelcolor can
+    also be made to match the color of the line or marker using 'linecolor',
+    'markerfacecolor' (or 'mfc'), or 'markeredgecolor' (or 'mec').
+
+    Labelcolor can be set globally using :rc:`legend.labelcolor`. If None,
+    use :rc:`text.color`.
+
+numpoints : int, default: :rc:`legend.numpoints`
+    The number of marker points in the legend when creating a legend
+    entry for a `.Line2D` (line).
+
+scatterpoints : int, default: :rc:`legend.scatterpoints`
+    The number of marker points in the legend when creating
+    a legend entry for a `.PathCollection` (scatter plot).
+
+scatteryoffsets : iterable of floats, default: ``[0.375, 0.5, 0.3125]``
+    The vertical offset (relative to the font size) for the markers
+    created for a scatter plot legend entry. 0.0 is at the base the
+    legend text, and 1.0 is at the top. To draw all markers at the
+    same height, set to ``[0.5]``.
+
+markerscale : float, default: :rc:`legend.markerscale`
+    The relative size of legend markers compared to the originally drawn ones.
+
+markerfirst : bool, default: True
+    If *True*, legend marker is placed to the left of the legend label.
+    If *False*, legend marker is placed to the right of the legend label.
+
+reverse : bool, default: False
+    If *True*, the legend labels are displayed in reverse order from the input.
+    If *False*, the legend labels are displayed in the same order as the input.
+
+    .. versionadded:: 3.7
+
+frameon : bool, default: :rc:`legend.frameon`
+    Whether the legend should be drawn on a patch (frame).
+
+fancybox : bool, default: :rc:`legend.fancybox`
+    Whether round edges should be enabled around the `.FancyBboxPatch` which
+    makes up the legend's background.
+
+shadow : None, bool or dict, default: :rc:`legend.shadow`
+    Whether to draw a shadow behind the legend.
+    The shadow can be configured using `.Patch` keywords.
+    Customization via :rc:`legend.shadow` is currently not supported.
+
+framealpha : float, default: :rc:`legend.framealpha`
+    The alpha transparency of the legend's background.
+    If *shadow* is activated and *framealpha* is ``None``, the default value is
+    ignored.
+
+facecolor : "inherit" or color, default: :rc:`legend.facecolor`
+    The legend's background color.
+    If ``"inherit"``, use :rc:`axes.facecolor`.
+
+edgecolor : "inherit" or color, default: :rc:`legend.edgecolor`
+    The legend's background patch edge color.
+    If ``"inherit"``, use :rc:`axes.edgecolor`.
+
+mode : {"expand", None}
+    If *mode* is set to ``"expand"`` the legend will be horizontally
+    expanded to fill the Axes area (or *bbox_to_anchor* if defines
+    the legend's size).
+
+bbox_transform : None or `~matplotlib.transforms.Transform`
+    The transform for the bounding box (*bbox_to_anchor*). For a value
+    of ``None`` (default) the Axes'
+    :data:`~matplotlib.axes.Axes.transAxes` transform will be used.
+
+title : str or None
+    The legend's title. Default is no title (``None``).
+
+title_fontproperties : None or `~matplotlib.font_manager.FontProperties` or dict
+    The font properties of the legend's title. If None (default), the
+    *title_fontsize* argument will be used if present; if *title_fontsize* is
+    also None, the current :rc:`legend.title_fontsize` will be used.
+
+title_fontsize : int or {'xx-small', 'x-small', 'small', 'medium', 'large', \
+'x-large', 'xx-large'}, default: :rc:`legend.title_fontsize`
+    The font size of the legend's title.
+    Note: This cannot be combined with *title_fontproperties*. If you want
+    to set the fontsize alongside other font properties, use the *size*
+    parameter in *title_fontproperties*.
+
+alignment : {'center', 'left', 'right'}, default: 'center'
+    The alignment of the legend title and the box of entries. The entries
+    are aligned as a single block, so that markers always lined up.
+
+borderpad : float, default: :rc:`legend.borderpad`
+    The fractional whitespace inside the legend border, in font-size units.
+
+labelspacing : float, default: :rc:`legend.labelspacing`
+    The vertical space between the legend entries, in font-size units.
+
+handlelength : float, default: :rc:`legend.handlelength`
+    The length of the legend handles, in font-size units.
+
+handleheight : float, default: :rc:`legend.handleheight`
+    The height of the legend handles, in font-size units.
+
+handletextpad : float, default: :rc:`legend.handletextpad`
+    The pad between the legend handle and text, in font-size units.
+
+borderaxespad : float, default: :rc:`legend.borderaxespad`
+    The pad between the Axes and legend border, in font-size units.
+
+columnspacing : float, default: :rc:`legend.columnspacing`
+    The spacing between columns, in font-size units.
+
+handler_map : dict or None
+    The custom dictionary mapping instances or types to a legend
+    handler. This *handler_map* updates the default handler map
+    found at `matplotlib.legend.Legend.get_legend_handler_map`.
+
+draggable : bool, default: False
+    Whether the legend can be dragged with the mouse.
+"""
+
+_loc_doc_base = """
+loc : str or pair of floats, default: {default}
+    The location of the legend.
+
+    The strings ``'upper left'``, ``'upper right'``, ``'lower left'``,
+    ``'lower right'`` place the legend at the corresponding corner of the
+    {parent}.
+
+    The strings ``'upper center'``, ``'lower center'``, ``'center left'``,
+    ``'center right'`` place the legend at the center of the corresponding edge
+    of the {parent}.
+
+    The string ``'center'`` places the legend at the center of the {parent}.
+{best}
+    The location can also be a 2-tuple giving the coordinates of the lower-left
+    corner of the legend in {parent} coordinates (in which case *bbox_to_anchor*
+    will be ignored).
+
+    For back-compatibility, ``'center right'`` (but no other location) can also
+    be spelled ``'right'``, and each "string" location can also be given as a
+    numeric value:
+
+    ==================   =============
+    Location String      Location Code
+    ==================   =============
+    'best' (Axes only)   0
+    'upper right'        1
+    'upper left'         2
+    'lower left'         3
+    'lower right'        4
+    'right'              5
+    'center left'        6
+    'center right'       7
+    'lower center'       8
+    'upper center'       9
+    'center'             10
+    ==================   =============
+    {outside}"""
+
+_loc_doc_best = """
+    The string ``'best'`` places the legend at the location, among the nine
+    locations defined so far, with the minimum overlap with other drawn
+    artists.  This option can be quite slow for plots with large amounts of
+    data; your plotting speed may benefit from providing a specific location.
+"""
+
+_legend_kw_axes_st = (
+    _loc_doc_base.format(parent='axes', default=':rc:`legend.loc`',
+                         best=_loc_doc_best, outside='') +
+    _legend_kw_doc_base)
+_docstring.interpd.update(_legend_kw_axes=_legend_kw_axes_st)
+
+_outside_doc = """
+    If a figure is using the constrained layout manager, the string codes
+    of the *loc* keyword argument can get better layout behaviour using the
+    prefix 'outside'. There is ambiguity at the corners, so 'outside
+    upper right' will make space for the legend above the rest of the
+    axes in the layout, and 'outside right upper' will make space on the
+    right side of the layout.  In addition to the values of *loc*
+    listed above, we have 'outside right upper', 'outside right lower',
+    'outside left upper', and 'outside left lower'.  See
+    :ref:`legend_guide` for more details.
+"""
+
+_legend_kw_figure_st = (
+    _loc_doc_base.format(parent='figure', default="'upper right'",
+                         best='', outside=_outside_doc) +
+    _legend_kw_doc_base)
+_docstring.interpd.update(_legend_kw_figure=_legend_kw_figure_st)
+
+_legend_kw_both_st = (
+    _loc_doc_base.format(parent='axes/figure',
+                         default=":rc:`legend.loc` for Axes, 'upper right' for Figure",
+                         best=_loc_doc_best, outside=_outside_doc) +
+    _legend_kw_doc_base)
+_docstring.interpd.update(_legend_kw_doc=_legend_kw_both_st)
+
+_legend_kw_set_loc_st = (
+    _loc_doc_base.format(parent='axes/figure',
+                         default=":rc:`legend.loc` for Axes, 'upper right' for Figure",
+                         best=_loc_doc_best, outside=_outside_doc))
+_docstring.interpd.update(_legend_kw_set_loc_doc=_legend_kw_set_loc_st)
+
+
+class Legend(Artist):
+    """
+    Place a legend on the figure/axes.
+    """
+
+    # 'best' is only implemented for Axes legends
+    codes = {'best': 0, **AnchoredOffsetbox.codes}
+    zorder = 5
+
+    def __str__(self):
+        return "Legend"
+
+    @_docstring.dedent_interpd
+    def __init__(
+        self, parent, handles, labels,
+        *,
+        loc=None,
+        numpoints=None,      # number of points in the legend line
+        markerscale=None,    # relative size of legend markers vs. original
+        markerfirst=True,    # left/right ordering of legend marker and label
+        reverse=False,       # reverse ordering of legend marker and label
+        scatterpoints=None,  # number of scatter points
+        scatteryoffsets=None,
+        prop=None,           # properties for the legend texts
+        fontsize=None,       # keyword to set font size directly
+        labelcolor=None,     # keyword to set the text color
+
+        # spacing & pad defined as a fraction of the font-size
+        borderpad=None,      # whitespace inside the legend border
+        labelspacing=None,   # vertical space between the legend entries
+        handlelength=None,   # length of the legend handles
+        handleheight=None,   # height of the legend handles
+        handletextpad=None,  # pad between the legend handle and text
+        borderaxespad=None,  # pad between the Axes and legend border
+        columnspacing=None,  # spacing between columns
+
+        ncols=1,     # number of columns
+        mode=None,  # horizontal distribution of columns: None or "expand"
+
+        fancybox=None,  # True: fancy box, False: rounded box, None: rcParam
+        shadow=None,
+        title=None,           # legend title
+        title_fontsize=None,  # legend title font size
+        framealpha=None,      # set frame alpha
+        edgecolor=None,       # frame patch edgecolor
+        facecolor=None,       # frame patch facecolor
+
+        bbox_to_anchor=None,  # bbox to which the legend will be anchored
+        bbox_transform=None,  # transform for the bbox
+        frameon=None,         # draw frame
+        handler_map=None,
+        title_fontproperties=None,  # properties for the legend title
+        alignment="center",       # control the alignment within the legend box
+        ncol=1,  # synonym for ncols (backward compatibility)
+        draggable=False  # whether the legend can be dragged with the mouse
+    ):
+        """
+        Parameters
+        ----------
+        parent : `~matplotlib.axes.Axes` or `.Figure`
+            The artist that contains the legend.
+
+        handles : list of (`.Artist` or tuple of `.Artist`)
+            A list of Artists (lines, patches) to be added to the legend.
+
+        labels : list of str
+            A list of labels to show next to the artists. The length of handles
+            and labels should be the same. If they are not, they are truncated
+            to the length of the shorter list.
+
+        Other Parameters
+        ----------------
+        %(_legend_kw_doc)s
+
+        Attributes
+        ----------
+        legend_handles
+            List of `.Artist` objects added as legend entries.
+
+            .. versionadded:: 3.7
+        """
+        # local import only to avoid circularity
+        from matplotlib.axes import Axes
+        from matplotlib.figure import FigureBase
+
+        super().__init__()
+
+        if prop is None:
+            self.prop = FontProperties(size=mpl._val_or_rc(fontsize, "legend.fontsize"))
+        else:
+            self.prop = FontProperties._from_any(prop)
+            if isinstance(prop, dict) and "size" not in prop:
+                self.prop.set_size(mpl.rcParams["legend.fontsize"])
+
+        self._fontsize = self.prop.get_size_in_points()
+
+        self.texts = []
+        self.legend_handles = []
+        self._legend_title_box = None
+
+        #: A dictionary with the extra handler mappings for this Legend
+        #: instance.
+        self._custom_handler_map = handler_map
+
+        self.numpoints = mpl._val_or_rc(numpoints, 'legend.numpoints')
+        self.markerscale = mpl._val_or_rc(markerscale, 'legend.markerscale')
+        self.scatterpoints = mpl._val_or_rc(scatterpoints, 'legend.scatterpoints')
+        self.borderpad = mpl._val_or_rc(borderpad, 'legend.borderpad')
+        self.labelspacing = mpl._val_or_rc(labelspacing, 'legend.labelspacing')
+        self.handlelength = mpl._val_or_rc(handlelength, 'legend.handlelength')
+        self.handleheight = mpl._val_or_rc(handleheight, 'legend.handleheight')
+        self.handletextpad = mpl._val_or_rc(handletextpad, 'legend.handletextpad')
+        self.borderaxespad = mpl._val_or_rc(borderaxespad, 'legend.borderaxespad')
+        self.columnspacing = mpl._val_or_rc(columnspacing, 'legend.columnspacing')
+        self.shadow = mpl._val_or_rc(shadow, 'legend.shadow')
+        # trim handles and labels if illegal label...
+        _lab, _hand = [], []
+        for label, handle in zip(labels, handles):
+            if isinstance(label, str) and label.startswith('_'):
+                _api.warn_deprecated("3.8", message=(
+                    "An artist whose label starts with an underscore was passed to "
+                    "legend(); such artists will no longer be ignored in the future.  "
+                    "To suppress this warning, explicitly filter out such artists, "
+                    "e.g. with `[art for art in artists if not "
+                    "art.get_label().startswith('_')]`."))
+            else:
+                _lab.append(label)
+                _hand.append(handle)
+        labels, handles = _lab, _hand
+
+        if reverse:
+            labels.reverse()
+            handles.reverse()
+
+        if len(handles) < 2:
+            ncols = 1
+        self._ncols = ncols if ncols != 1 else ncol
+
+        if self.numpoints <= 0:
+            raise ValueError("numpoints must be > 0; it was %d" % numpoints)
+
+        # introduce y-offset for handles of the scatter plot
+        if scatteryoffsets is None:
+            self._scatteryoffsets = np.array([3. / 8., 4. / 8., 2.5 / 8.])
+        else:
+            self._scatteryoffsets = np.asarray(scatteryoffsets)
+        reps = self.scatterpoints // len(self._scatteryoffsets) + 1
+        self._scatteryoffsets = np.tile(self._scatteryoffsets,
+                                        reps)[:self.scatterpoints]
+
+        # _legend_box is a VPacker instance that contains all
+        # legend items and will be initialized from _init_legend_box()
+        # method.
+        self._legend_box = None
+
+        if isinstance(parent, Axes):
+            self.isaxes = True
+            self.axes = parent
+            self.set_figure(parent.figure)
+        elif isinstance(parent, FigureBase):
+            self.isaxes = False
+            self.set_figure(parent)
+        else:
+            raise TypeError(
+                "Legend needs either Axes or FigureBase as parent"
+            )
+        self.parent = parent
+
+        self._mode = mode
+        self.set_bbox_to_anchor(bbox_to_anchor, bbox_transform)
+
+        # Figure out if self.shadow is valid
+        # If shadow was None, rcParams loads False
+        # So it shouldn't be None here
+
+        self._shadow_props = {'ox': 2, 'oy': -2}  # default location offsets
+        if isinstance(self.shadow, dict):
+            self._shadow_props.update(self.shadow)
+            self.shadow = True
+        elif self.shadow in (0, 1, True, False):
+            self.shadow = bool(self.shadow)
+        else:
+            raise ValueError(
+                'Legend shadow must be a dict or bool, not '
+                f'{self.shadow!r} of type {type(self.shadow)}.'
+            )
+
+        # We use FancyBboxPatch to draw a legend frame. The location
+        # and size of the box will be updated during the drawing time.
+
+        facecolor = mpl._val_or_rc(facecolor, "legend.facecolor")
+        if facecolor == 'inherit':
+            facecolor = mpl.rcParams["axes.facecolor"]
+
+        edgecolor = mpl._val_or_rc(edgecolor, "legend.edgecolor")
+        if edgecolor == 'inherit':
+            edgecolor = mpl.rcParams["axes.edgecolor"]
+
+        fancybox = mpl._val_or_rc(fancybox, "legend.fancybox")
+
+        self.legendPatch = FancyBboxPatch(
+            xy=(0, 0), width=1, height=1,
+            facecolor=facecolor, edgecolor=edgecolor,
+            # If shadow is used, default to alpha=1 (#8943).
+            alpha=(framealpha if framealpha is not None
+                   else 1 if shadow
+                   else mpl.rcParams["legend.framealpha"]),
+            # The width and height of the legendPatch will be set (in draw())
+            # to the length that includes the padding. Thus we set pad=0 here.
+            boxstyle=("round,pad=0,rounding_size=0.2" if fancybox
+                      else "square,pad=0"),
+            mutation_scale=self._fontsize,
+            snap=True,
+            visible=mpl._val_or_rc(frameon, "legend.frameon")
+        )
+        self._set_artist_props(self.legendPatch)
+
+        _api.check_in_list(["center", "left", "right"], alignment=alignment)
+        self._alignment = alignment
+
+        # init with null renderer
+        self._init_legend_box(handles, labels, markerfirst)
+
+        # Set legend location
+        self.set_loc(loc)
+
+        # figure out title font properties:
+        if title_fontsize is not None and title_fontproperties is not None:
+            raise ValueError(
+                "title_fontsize and title_fontproperties can't be specified "
+                "at the same time. Only use one of them. ")
+        title_prop_fp = FontProperties._from_any(title_fontproperties)
+        if isinstance(title_fontproperties, dict):
+            if "size" not in title_fontproperties:
+                title_fontsize = mpl.rcParams["legend.title_fontsize"]
+                title_prop_fp.set_size(title_fontsize)
+        elif title_fontsize is not None:
+            title_prop_fp.set_size(title_fontsize)
+        elif not isinstance(title_fontproperties, FontProperties):
+            title_fontsize = mpl.rcParams["legend.title_fontsize"]
+            title_prop_fp.set_size(title_fontsize)
+
+        self.set_title(title, prop=title_prop_fp)
+
+        self._draggable = None
+        self.set_draggable(state=draggable)
+
+        # set the text color
+
+        color_getters = {  # getter function depends on line or patch
+            'linecolor':       ['get_color',           'get_facecolor'],
+            'markerfacecolor': ['get_markerfacecolor', 'get_facecolor'],
+            'mfc':             ['get_markerfacecolor', 'get_facecolor'],
+            'markeredgecolor': ['get_markeredgecolor', 'get_edgecolor'],
+            'mec':             ['get_markeredgecolor', 'get_edgecolor'],
+        }
+        labelcolor = mpl._val_or_rc(labelcolor, 'legend.labelcolor')
+        if labelcolor is None:
+            labelcolor = mpl.rcParams['text.color']
+        if isinstance(labelcolor, str) and labelcolor in color_getters:
+            getter_names = color_getters[labelcolor]
+            for handle, text in zip(self.legend_handles, self.texts):
+                try:
+                    if handle.get_array() is not None:
+                        continue
+                except AttributeError:
+                    pass
+                for getter_name in getter_names:
+                    try:
+                        color = getattr(handle, getter_name)()
+                        if isinstance(color, np.ndarray):
+                            if (
+                                    color.shape[0] == 1
+                                    or np.isclose(color, color[0]).all()
+                            ):
+                                text.set_color(color[0])
+                            else:
+                                pass
+                        else:
+                            text.set_color(color)
+                        break
+                    except AttributeError:
+                        pass
+        elif cbook._str_equal(labelcolor, 'none'):
+            for text in self.texts:
+                text.set_color(labelcolor)
+        elif np.iterable(labelcolor):
+            for text, color in zip(self.texts,
+                                   itertools.cycle(
+                                       colors.to_rgba_array(labelcolor))):
+                text.set_color(color)
+        else:
+            raise ValueError(f"Invalid labelcolor: {labelcolor!r}")
+
+    def _set_artist_props(self, a):
+        """
+        Set the boilerplate props for artists added to Axes.
+        """
+        a.set_figure(self.figure)
+        if self.isaxes:
+            a.axes = self.axes
+
+        a.set_transform(self.get_transform())
+
+    @_docstring.dedent_interpd
+    def set_loc(self, loc=None):
+        """
+        Set the location of the legend.
+
+        .. versionadded:: 3.8
+
+        Parameters
+        ----------
+        %(_legend_kw_set_loc_doc)s
+        """
+        loc0 = loc
+        self._loc_used_default = loc is None
+        if loc is None:
+            loc = mpl.rcParams["legend.loc"]
+            if not self.isaxes and loc in [0, 'best']:
+                loc = 'upper right'
+
+        type_err_message = ("loc must be string, coordinate tuple, or"
+                            f" an integer 0-10, not {loc!r}")
+
+        # handle outside legends:
+        self._outside_loc = None
+        if isinstance(loc, str):
+            if loc.split()[0] == 'outside':
+                # strip outside:
+                loc = loc.split('outside ')[1]
+                # strip "center" at the beginning
+                self._outside_loc = loc.replace('center ', '')
+                # strip first
+                self._outside_loc = self._outside_loc.split()[0]
+                locs = loc.split()
+                if len(locs) > 1 and locs[0] in ('right', 'left'):
+                    # locs doesn't accept "left upper", etc, so swap
+                    if locs[0] != 'center':
+                        locs = locs[::-1]
+                    loc = locs[0] + ' ' + locs[1]
+            # check that loc is in acceptable strings
+            loc = _api.check_getitem(self.codes, loc=loc)
+        elif np.iterable(loc):
+            # coerce iterable into tuple
+            loc = tuple(loc)
+            # validate the tuple represents Real coordinates
+            if len(loc) != 2 or not all(isinstance(e, numbers.Real) for e in loc):
+                raise ValueError(type_err_message)
+        elif isinstance(loc, int):
+            # validate the integer represents a string numeric value
+            if loc < 0 or loc > 10:
+                raise ValueError(type_err_message)
+        else:
+            # all other cases are invalid values of loc
+            raise ValueError(type_err_message)
+
+        if self.isaxes and self._outside_loc:
+            raise ValueError(
+                f"'outside' option for loc='{loc0}' keyword argument only "
+                "works for figure legends")
+
+        if not self.isaxes and loc == 0:
+            raise ValueError(
+                "Automatic legend placement (loc='best') not implemented for "
+                "figure legend")
+
+        tmp = self._loc_used_default
+        self._set_loc(loc)
+        self._loc_used_default = tmp  # ignore changes done by _set_loc
+
+    def _set_loc(self, loc):
+        # find_offset function will be provided to _legend_box and
+        # _legend_box will draw itself at the location of the return
+        # value of the find_offset.
+        self._loc_used_default = False
+        self._loc_real = loc
+        self.stale = True
+        self._legend_box.set_offset(self._findoffset)
+
+    def set_ncols(self, ncols):
+        """Set the number of columns."""
+        self._ncols = ncols
+
+    def _get_loc(self):
+        return self._loc_real
+
+    _loc = property(_get_loc, _set_loc)
+
+    def _findoffset(self, width, height, xdescent, ydescent, renderer):
+        """Helper function to locate the legend."""
+
+        if self._loc == 0:  # "best".
+            x, y = self._find_best_position(width, height, renderer)
+        elif self._loc in Legend.codes.values():  # Fixed location.
+            bbox = Bbox.from_bounds(0, 0, width, height)
+            x, y = self._get_anchored_bbox(self._loc, bbox,
+                                           self.get_bbox_to_anchor(),
+                                           renderer)
+        else:  # Axes or figure coordinates.
+            fx, fy = self._loc
+            bbox = self.get_bbox_to_anchor()
+            x, y = bbox.x0 + bbox.width * fx, bbox.y0 + bbox.height * fy
+
+        return x + xdescent, y + ydescent
+
+    @allow_rasterization
+    def draw(self, renderer):
+        # docstring inherited
+        if not self.get_visible():
+            return
+
+        renderer.open_group('legend', gid=self.get_gid())
+
+        fontsize = renderer.points_to_pixels(self._fontsize)
+
+        # if mode == fill, set the width of the legend_box to the
+        # width of the parent (minus pads)
+        if self._mode in ["expand"]:
+            pad = 2 * (self.borderaxespad + self.borderpad) * fontsize
+            self._legend_box.set_width(self.get_bbox_to_anchor().width - pad)
+
+        # update the location and size of the legend. This needs to
+        # be done in any case to clip the figure right.
+        bbox = self._legend_box.get_window_extent(renderer)
+        self.legendPatch.set_bounds(bbox.bounds)
+        self.legendPatch.set_mutation_scale(fontsize)
+
+        # self.shadow is validated in __init__
+        # So by here it is a bool and self._shadow_props contains any configs
+
+        if self.shadow:
+            Shadow(self.legendPatch, **self._shadow_props).draw(renderer)
+
+        self.legendPatch.draw(renderer)
+        self._legend_box.draw(renderer)
+
+        renderer.close_group('legend')
+        self.stale = False
+
+    # _default_handler_map defines the default mapping between plot
+    # elements and the legend handlers.
+
+    _default_handler_map = {
+        StemContainer: legend_handler.HandlerStem(),
+        ErrorbarContainer: legend_handler.HandlerErrorbar(),
+        Line2D: legend_handler.HandlerLine2D(),
+        Patch: legend_handler.HandlerPatch(),
+        StepPatch: legend_handler.HandlerStepPatch(),
+        LineCollection: legend_handler.HandlerLineCollection(),
+        RegularPolyCollection: legend_handler.HandlerRegularPolyCollection(),
+        CircleCollection: legend_handler.HandlerCircleCollection(),
+        BarContainer: legend_handler.HandlerPatch(
+            update_func=legend_handler.update_from_first_child),
+        tuple: legend_handler.HandlerTuple(),
+        PathCollection: legend_handler.HandlerPathCollection(),
+        PolyCollection: legend_handler.HandlerPolyCollection()
+        }
+
+    # (get|set|update)_default_handler_maps are public interfaces to
+    # modify the default handler map.
+
+    @classmethod
+    def get_default_handler_map(cls):
+        """Return the global default handler map, shared by all legends."""
+        return cls._default_handler_map
+
+    @classmethod
+    def set_default_handler_map(cls, handler_map):
+        """Set the global default handler map, shared by all legends."""
+        cls._default_handler_map = handler_map
+
+    @classmethod
+    def update_default_handler_map(cls, handler_map):
+        """Update the global default handler map, shared by all legends."""
+        cls._default_handler_map.update(handler_map)
+
+    def get_legend_handler_map(self):
+        """Return this legend instance's handler map."""
+        default_handler_map = self.get_default_handler_map()
+        return ({**default_handler_map, **self._custom_handler_map}
+                if self._custom_handler_map else default_handler_map)
+
+    @staticmethod
+    def get_legend_handler(legend_handler_map, orig_handle):
+        """
+        Return a legend handler from *legend_handler_map* that
+        corresponds to *orig_handler*.
+
+        *legend_handler_map* should be a dictionary object (that is
+        returned by the get_legend_handler_map method).
+
+        It first checks if the *orig_handle* itself is a key in the
+        *legend_handler_map* and return the associated value.
+        Otherwise, it checks for each of the classes in its
+        method-resolution-order. If no matching key is found, it
+        returns ``None``.
+        """
+        try:
+            return legend_handler_map[orig_handle]
+        except (TypeError, KeyError):  # TypeError if unhashable.
+            pass
+        for handle_type in type(orig_handle).mro():
+            try:
+                return legend_handler_map[handle_type]
+            except KeyError:
+                pass
+        return None
+
+    def _init_legend_box(self, handles, labels, markerfirst=True):
+        """
+        Initialize the legend_box. The legend_box is an instance of
+        the OffsetBox, which is packed with legend handles and
+        texts. Once packed, their location is calculated during the
+        drawing time.
+        """
+
+        fontsize = self._fontsize
+
+        # legend_box is a HPacker, horizontally packed with columns.
+        # Each column is a VPacker, vertically packed with legend items.
+        # Each legend item is a HPacker packed with:
+        # - handlebox: a DrawingArea which contains the legend handle.
+        # - labelbox: a TextArea which contains the legend text.
+
+        text_list = []  # the list of text instances
+        handle_list = []  # the list of handle instances
+        handles_and_labels = []
+
+        # The approximate height and descent of text. These values are
+        # only used for plotting the legend handle.
+        descent = 0.35 * fontsize * (self.handleheight - 0.7)  # heuristic.
+        height = fontsize * self.handleheight - descent
+        # each handle needs to be drawn inside a box of (x, y, w, h) =
+        # (0, -descent, width, height).  And their coordinates should
+        # be given in the display coordinates.
+
+        # The transformation of each handle will be automatically set
+        # to self.get_transform(). If the artist does not use its
+        # default transform (e.g., Collections), you need to
+        # manually set their transform to the self.get_transform().
+        legend_handler_map = self.get_legend_handler_map()
+
+        for orig_handle, label in zip(handles, labels):
+            handler = self.get_legend_handler(legend_handler_map, orig_handle)
+            if handler is None:
+                _api.warn_external(
+                             "Legend does not support handles for "
+                             f"{type(orig_handle).__name__} "
+                             "instances.\nA proxy artist may be used "
+                             "instead.\nSee: https://matplotlib.org/"
+                             "stable/users/explain/axes/legend_guide.html"
+                             "#controlling-the-legend-entries")
+                # No handle for this artist, so we just defer to None.
+                handle_list.append(None)
+            else:
+                textbox = TextArea(label, multilinebaseline=True,
+                                   textprops=dict(
+                                       verticalalignment='baseline',
+                                       horizontalalignment='left',
+                                       fontproperties=self.prop))
+                handlebox = DrawingArea(width=self.handlelength * fontsize,
+                                        height=height,
+                                        xdescent=0., ydescent=descent)
+
+                text_list.append(textbox._text)
+                # Create the artist for the legend which represents the
+                # original artist/handle.
+                handle_list.append(handler.legend_artist(self, orig_handle,
+                                                         fontsize, handlebox))
+                handles_and_labels.append((handlebox, textbox))
+
+        columnbox = []
+        # array_split splits n handles_and_labels into ncols columns, with the
+        # first n%ncols columns having an extra entry.  filter(len, ...)
+        # handles the case where n < ncols: the last ncols-n columns are empty
+        # and get filtered out.
+        for handles_and_labels_column in filter(
+                len, np.array_split(handles_and_labels, self._ncols)):
+            # pack handlebox and labelbox into itembox
+            itemboxes = [HPacker(pad=0,
+                                 sep=self.handletextpad * fontsize,
+                                 children=[h, t] if markerfirst else [t, h],
+                                 align="baseline")
+                         for h, t in handles_and_labels_column]
+            # pack columnbox
+            alignment = "baseline" if markerfirst else "right"
+            columnbox.append(VPacker(pad=0,
+                                     sep=self.labelspacing * fontsize,
+                                     align=alignment,
+                                     children=itemboxes))
+
+        mode = "expand" if self._mode == "expand" else "fixed"
+        sep = self.columnspacing * fontsize
+        self._legend_handle_box = HPacker(pad=0,
+                                          sep=sep, align="baseline",
+                                          mode=mode,
+                                          children=columnbox)
+        self._legend_title_box = TextArea("")
+        self._legend_box = VPacker(pad=self.borderpad * fontsize,
+                                   sep=self.labelspacing * fontsize,
+                                   align=self._alignment,
+                                   children=[self._legend_title_box,
+                                             self._legend_handle_box])
+        self._legend_box.set_figure(self.figure)
+        self._legend_box.axes = self.axes
+        self.texts = text_list
+        self.legend_handles = handle_list
+
+    def _auto_legend_data(self):
+        """
+        Return display coordinates for hit testing for "best" positioning.
+
+        Returns
+        -------
+        bboxes
+            List of bounding boxes of all patches.
+        lines
+            List of `.Path` corresponding to each line.
+        offsets
+            List of (x, y) offsets of all collection.
+        """
+        assert self.isaxes  # always holds, as this is only called internally
+        bboxes = []
+        lines = []
+        offsets = []
+        for artist in self.parent._children:
+            if isinstance(artist, Line2D):
+                lines.append(
+                    artist.get_transform().transform_path(artist.get_path()))
+            elif isinstance(artist, Rectangle):
+                bboxes.append(
+                    artist.get_bbox().transformed(artist.get_data_transform()))
+            elif isinstance(artist, Patch):
+                lines.append(
+                    artist.get_transform().transform_path(artist.get_path()))
+            elif isinstance(artist, PolyCollection):
+                lines.extend(artist.get_transform().transform_path(path)
+                             for path in artist.get_paths())
+            elif isinstance(artist, Collection):
+                transform, transOffset, hoffsets, _ = artist._prepare_points()
+                if len(hoffsets):
+                    offsets.extend(transOffset.transform(hoffsets))
+            elif isinstance(artist, Text):
+                bboxes.append(artist.get_window_extent())
+
+        return bboxes, lines, offsets
+
+    def get_children(self):
+        # docstring inherited
+        return [self._legend_box, self.get_frame()]
+
+    def get_frame(self):
+        """Return the `~.patches.Rectangle` used to frame the legend."""
+        return self.legendPatch
+
+    def get_lines(self):
+        r"""Return the list of `~.lines.Line2D`\s in the legend."""
+        return [h for h in self.legend_handles if isinstance(h, Line2D)]
+
+    def get_patches(self):
+        r"""Return the list of `~.patches.Patch`\s in the legend."""
+        return silent_list('Patch',
+                           [h for h in self.legend_handles
+                            if isinstance(h, Patch)])
+
+    def get_texts(self):
+        r"""Return the list of `~.text.Text`\s in the legend."""
+        return silent_list('Text', self.texts)
+
+    def set_alignment(self, alignment):
+        """
+        Set the alignment of the legend title and the box of entries.
+
+        The entries are aligned as a single block, so that markers always
+        lined up.
+
+        Parameters
+        ----------
+        alignment : {'center', 'left', 'right'}.
+
+        """
+        _api.check_in_list(["center", "left", "right"], alignment=alignment)
+        self._alignment = alignment
+        self._legend_box.align = alignment
+
+    def get_alignment(self):
+        """Get the alignment value of the legend box"""
+        return self._legend_box.align
+
+    def set_title(self, title, prop=None):
+        """
+        Set legend title and title style.
+
+        Parameters
+        ----------
+        title : str
+            The legend title.
+
+        prop : `.font_manager.FontProperties` or `str` or `pathlib.Path`
+            The font properties of the legend title.
+            If a `str`, it is interpreted as a fontconfig pattern parsed by
+            `.FontProperties`.  If a `pathlib.Path`, it is interpreted as the
+            absolute path to a font file.
+
+        """
+        self._legend_title_box._text.set_text(title)
+        if title:
+            self._legend_title_box._text.set_visible(True)
+            self._legend_title_box.set_visible(True)
+        else:
+            self._legend_title_box._text.set_visible(False)
+            self._legend_title_box.set_visible(False)
+
+        if prop is not None:
+            self._legend_title_box._text.set_fontproperties(prop)
+
+        self.stale = True
+
+    def get_title(self):
+        """Return the `.Text` instance for the legend title."""
+        return self._legend_title_box._text
+
+    def get_window_extent(self, renderer=None):
+        # docstring inherited
+        if renderer is None:
+            renderer = self.figure._get_renderer()
+        return self._legend_box.get_window_extent(renderer=renderer)
+
+    def get_tightbbox(self, renderer=None):
+        # docstring inherited
+        return self._legend_box.get_window_extent(renderer)
+
+    def get_frame_on(self):
+        """Get whether the legend box patch is drawn."""
+        return self.legendPatch.get_visible()
+
+    def set_frame_on(self, b):
+        """
+        Set whether the legend box patch is drawn.
+
+        Parameters
+        ----------
+        b : bool
+        """
+        self.legendPatch.set_visible(b)
+        self.stale = True
+
+    draw_frame = set_frame_on  # Backcompat alias.
+
+    def get_bbox_to_anchor(self):
+        """Return the bbox that the legend will be anchored to."""
+        if self._bbox_to_anchor is None:
+            return self.parent.bbox
+        else:
+            return self._bbox_to_anchor
+
+    def set_bbox_to_anchor(self, bbox, transform=None):
+        """
+        Set the bbox that the legend will be anchored to.
+
+        Parameters
+        ----------
+        bbox : `~matplotlib.transforms.BboxBase` or tuple
+            The bounding box can be specified in the following ways:
+
+            - A `.BboxBase` instance
+            - A tuple of ``(left, bottom, width, height)`` in the given
+              transform (normalized axes coordinate if None)
+            - A tuple of ``(left, bottom)`` where the width and height will be
+              assumed to be zero.
+            - *None*, to remove the bbox anchoring, and use the parent bbox.
+
+        transform : `~matplotlib.transforms.Transform`, optional
+            A transform to apply to the bounding box. If not specified, this
+            will use a transform to the bounding box of the parent.
+        """
+        if bbox is None:
+            self._bbox_to_anchor = None
+            return
+        elif isinstance(bbox, BboxBase):
+            self._bbox_to_anchor = bbox
+        else:
+            try:
+                l = len(bbox)
+            except TypeError as err:
+                raise ValueError(f"Invalid bbox: {bbox}") from err
+
+            if l == 2:
+                bbox = [bbox[0], bbox[1], 0, 0]
+
+            self._bbox_to_anchor = Bbox.from_bounds(*bbox)
+
+        if transform is None:
+            transform = BboxTransformTo(self.parent.bbox)
+
+        self._bbox_to_anchor = TransformedBbox(self._bbox_to_anchor,
+                                               transform)
+        self.stale = True
+
+    def _get_anchored_bbox(self, loc, bbox, parentbbox, renderer):
+        """
+        Place the *bbox* inside the *parentbbox* according to a given
+        location code. Return the (x, y) coordinate of the bbox.
+
+        Parameters
+        ----------
+        loc : int
+            A location code in range(1, 11). This corresponds to the possible
+            values for ``self._loc``, excluding "best".
+        bbox : `~matplotlib.transforms.Bbox`
+            bbox to be placed, in display coordinates.
+        parentbbox : `~matplotlib.transforms.Bbox`
+            A parent box which will contain the bbox, in display coordinates.
+        """
+        return offsetbox._get_anchored_bbox(
+            loc, bbox, parentbbox,
+            self.borderaxespad * renderer.points_to_pixels(self._fontsize))
+
+    def _find_best_position(self, width, height, renderer):
+        """Determine the best location to place the legend."""
+        assert self.isaxes  # always holds, as this is only called internally
+
+        start_time = time.perf_counter()
+
+        bboxes, lines, offsets = self._auto_legend_data()
+
+        bbox = Bbox.from_bounds(0, 0, width, height)
+
+        candidates = []
+        for idx in range(1, len(self.codes)):
+            l, b = self._get_anchored_bbox(idx, bbox,
+                                           self.get_bbox_to_anchor(),
+                                           renderer)
+            legendBox = Bbox.from_bounds(l, b, width, height)
+            # XXX TODO: If markers are present, it would be good to take them
+            # into account when checking vertex overlaps in the next line.
+            badness = (sum(legendBox.count_contains(line.vertices)
+                           for line in lines)
+                       + legendBox.count_contains(offsets)
+                       + legendBox.count_overlaps(bboxes)
+                       + sum(line.intersects_bbox(legendBox, filled=False)
+                             for line in lines))
+            # Include the index to favor lower codes in case of a tie.
+            candidates.append((badness, idx, (l, b)))
+            if badness == 0:
+                break
+
+        _, _, (l, b) = min(candidates)
+
+        if self._loc_used_default and time.perf_counter() - start_time > 1:
+            _api.warn_external(
+                'Creating legend with loc="best" can be slow with large '
+                'amounts of data.')
+
+        return l, b
+
+    @_api.rename_parameter("3.8", "event", "mouseevent")
+    def contains(self, mouseevent):
+        return self.legendPatch.contains(mouseevent)
+
+    def set_draggable(self, state, use_blit=False, update='loc'):
+        """
+        Enable or disable mouse dragging support of the legend.
+
+        Parameters
+        ----------
+        state : bool
+            Whether mouse dragging is enabled.
+        use_blit : bool, optional
+            Use blitting for faster image composition. For details see
+            :ref:`func-animation`.
+        update : {'loc', 'bbox'}, optional
+            The legend parameter to be changed when dragged:
+
+            - 'loc': update the *loc* parameter of the legend
+            - 'bbox': update the *bbox_to_anchor* parameter of the legend
+
+        Returns
+        -------
+        `.DraggableLegend` or *None*
+            If *state* is ``True`` this returns the `.DraggableLegend` helper
+            instance. Otherwise this returns *None*.
+        """
+        if state:
+            if self._draggable is None:
+                self._draggable = DraggableLegend(self,
+                                                  use_blit,
+                                                  update=update)
+        else:
+            if self._draggable is not None:
+                self._draggable.disconnect()
+            self._draggable = None
+        return self._draggable
+
+    def get_draggable(self):
+        """Return ``True`` if the legend is draggable, ``False`` otherwise."""
+        return self._draggable is not None
+
+
+# Helper functions to parse legend arguments for both `figure.legend` and
+# `axes.legend`:
+def _get_legend_handles(axs, legend_handler_map=None):
+    """Yield artists that can be used as handles in a legend."""
+    handles_original = []
+    for ax in axs:
+        handles_original += [
+            *(a for a in ax._children
+              if isinstance(a, (Line2D, Patch, Collection, Text))),
+            *ax.containers]
+        # support parasite Axes:
+        if hasattr(ax, 'parasites'):
+            for axx in ax.parasites:
+                handles_original += [
+                    *(a for a in axx._children
+                      if isinstance(a, (Line2D, Patch, Collection, Text))),
+                    *axx.containers]
+
+    handler_map = {**Legend.get_default_handler_map(),
+                   **(legend_handler_map or {})}
+    has_handler = Legend.get_legend_handler
+    for handle in handles_original:
+        label = handle.get_label()
+        if label != '_nolegend_' and has_handler(handler_map, handle):
+            yield handle
+        elif (label and not label.startswith('_') and
+                not has_handler(handler_map, handle)):
+            _api.warn_external(
+                             "Legend does not support handles for "
+                             f"{type(handle).__name__} "
+                             "instances.\nSee: https://matplotlib.org/stable/"
+                             "tutorials/intermediate/legend_guide.html"
+                             "#implementing-a-custom-legend-handler")
+            continue
+
+
+def _get_legend_handles_labels(axs, legend_handler_map=None):
+    """Return handles and labels for legend."""
+    handles = []
+    labels = []
+    for handle in _get_legend_handles(axs, legend_handler_map):
+        label = handle.get_label()
+        if label and not label.startswith('_'):
+            handles.append(handle)
+            labels.append(label)
+    return handles, labels
+
+
+def _parse_legend_args(axs, *args, handles=None, labels=None, **kwargs):
+    """
+    Get the handles and labels from the calls to either ``figure.legend``
+    or ``axes.legend``.
+
+    The parser is a bit involved because we support::
+
+        legend()
+        legend(labels)
+        legend(handles, labels)
+        legend(labels=labels)
+        legend(handles=handles)
+        legend(handles=handles, labels=labels)
+
+    The behavior for a mixture of positional and keyword handles and labels
+    is undefined and issues a warning; it will be an error in the future.
+
+    Parameters
+    ----------
+    axs : list of `.Axes`
+        If handles are not given explicitly, the artists in these Axes are
+        used as handles.
+    *args : tuple
+        Positional parameters passed to ``legend()``.
+    handles
+        The value of the keyword argument ``legend(handles=...)``, or *None*
+        if that keyword argument was not used.
+    labels
+        The value of the keyword argument ``legend(labels=...)``, or *None*
+        if that keyword argument was not used.
+    **kwargs
+        All other keyword arguments passed to ``legend()``.
+
+    Returns
+    -------
+    handles : list of (`.Artist` or tuple of `.Artist`)
+        The legend handles.
+    labels : list of str
+        The legend labels.
+    kwargs : dict
+        *kwargs* with keywords handles and labels removed.
+
+    """
+    log = logging.getLogger(__name__)
+
+    handlers = kwargs.get('handler_map')
+
+    if (handles is not None or labels is not None) and args:
+        _api.warn_deprecated("3.9", message=(
+            "You have mixed positional and keyword arguments, some input may "
+            "be discarded.  This is deprecated since %(since)s and will "
+            "become an error %(removal)s."))
+
+    if (hasattr(handles, "__len__") and
+            hasattr(labels, "__len__") and
+            len(handles) != len(labels)):
+        _api.warn_external(f"Mismatched number of handles and labels: "
+                           f"len(handles) = {len(handles)} "
+                           f"len(labels) = {len(labels)}")
+    # if got both handles and labels as kwargs, make same length
+    if handles and labels:
+        handles, labels = zip(*zip(handles, labels))
+
+    elif handles is not None and labels is None:
+        labels = [handle.get_label() for handle in handles]
+
+    elif labels is not None and handles is None:
+        # Get as many handles as there are labels.
+        handles = [handle for handle, label
+                   in zip(_get_legend_handles(axs, handlers), labels)]
+
+    elif len(args) == 0:  # 0 args: automatically detect labels and handles.
+        handles, labels = _get_legend_handles_labels(axs, handlers)
+        if not handles:
+            _api.warn_external(
+                "No artists with labels found to put in legend.  Note that "
+                "artists whose label start with an underscore are ignored "
+                "when legend() is called with no argument.")
+
+    elif len(args) == 1:  # 1 arg: user defined labels, automatic handle detection.
+        labels, = args
+        if any(isinstance(l, Artist) for l in labels):
+            raise TypeError("A single argument passed to legend() must be a "
+                            "list of labels, but found an Artist in there.")
+
+        # Get as many handles as there are labels.
+        handles = [handle for handle, label
+                   in zip(_get_legend_handles(axs, handlers), labels)]
+
+    elif len(args) == 2:  # 2 args: user defined handles and labels.
+        handles, labels = args[:2]
+
+    else:
+        raise _api.nargs_error('legend', '0-2', len(args))
+
+    return handles, labels, kwargs

llava_next/lib/python3.10/site-packages/matplotlib/markers.pyi

@@ -0,0 +1,51 @@
+from typing import Literal
+
+from .path import Path
+from .transforms import Affine2D, Transform
+
+from numpy.typing import ArrayLike
+from .typing import CapStyleType, FillStyleType, JoinStyleType
+
+TICKLEFT: int
+TICKRIGHT: int
+TICKUP: int
+TICKDOWN: int
+CARETLEFT: int
+CARETRIGHT: int
+CARETUP: int
+CARETDOWN: int
+CARETLEFTBASE: int
+CARETRIGHTBASE: int
+CARETUPBASE: int
+CARETDOWNBASE: int
+
+class MarkerStyle:
+    markers: dict[str | int, str]
+    filled_markers: tuple[str, ...]
+    fillstyles: tuple[FillStyleType, ...]
+
+    def __init__(
+        self,
+        marker: str | ArrayLike | Path | MarkerStyle,
+        fillstyle: FillStyleType | None = ...,
+        transform: Transform | None = ...,
+        capstyle: CapStyleType | None = ...,
+        joinstyle: JoinStyleType | None = ...,
+    ) -> None: ...
+    def __bool__(self) -> bool: ...
+    def is_filled(self) -> bool: ...
+    def get_fillstyle(self) -> FillStyleType: ...
+    def get_joinstyle(self) -> Literal["miter", "round", "bevel"]: ...
+    def get_capstyle(self) -> Literal["butt", "projecting", "round"]: ...
+    def get_marker(self) -> str | ArrayLike | Path | None: ...
+    def get_path(self) -> Path: ...
+    def get_transform(self) -> Transform: ...
+    def get_alt_path(self) -> Path | None: ...
+    def get_alt_transform(self) -> Transform: ...
+    def get_snap_threshold(self) -> float | None: ...
+    def get_user_transform(self) -> Transform | None: ...
+    def transformed(self, transform: Affine2D) -> MarkerStyle: ...
+    def rotated(
+        self, *, deg: float | None = ..., rad: float | None = ...
+    ) -> MarkerStyle: ...
+    def scaled(self, sx: float, sy: float | None = ...) -> MarkerStyle: ...

llava_next/lib/python3.10/site-packages/matplotlib/offsetbox.py

@@ -0,0 +1,1569 @@
+r"""
+Container classes for `.Artist`\s.
+
+`OffsetBox`
+    The base of all container artists defined in this module.
+
+`AnchoredOffsetbox`, `AnchoredText`
+    Anchor and align an arbitrary `.Artist` or a text relative to the parent
+    axes or a specific anchor point.
+
+`DrawingArea`
+    A container with fixed width and height. Children have a fixed position
+    inside the container and may be clipped.
+
+`HPacker`, `VPacker`
+    Containers for layouting their children vertically or horizontally.
+
+`PaddedBox`
+    A container to add a padding around an `.Artist`.
+
+`TextArea`
+    Contains a single `.Text` instance.
+"""
+
+import functools
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib import _api, _docstring
+import matplotlib.artist as martist
+import matplotlib.path as mpath
+import matplotlib.text as mtext
+import matplotlib.transforms as mtransforms
+from matplotlib.font_manager import FontProperties
+from matplotlib.image import BboxImage
+from matplotlib.patches import (
+    FancyBboxPatch, FancyArrowPatch, bbox_artist as mbbox_artist)
+from matplotlib.transforms import Bbox, BboxBase, TransformedBbox
+
+
+DEBUG = False
+
+
+def _compat_get_offset(meth):
+    """
+    Decorator for the get_offset method of OffsetBox and subclasses, that
+    allows supporting both the new signature (self, bbox, renderer) and the old
+    signature (self, width, height, xdescent, ydescent, renderer).
+    """
+    sigs = [lambda self, width, height, xdescent, ydescent, renderer: locals(),
+            lambda self, bbox, renderer: locals()]
+
+    @functools.wraps(meth)
+    def get_offset(self, *args, **kwargs):
+        params = _api.select_matching_signature(sigs, self, *args, **kwargs)
+        bbox = (params["bbox"] if "bbox" in params else
+                Bbox.from_bounds(-params["xdescent"], -params["ydescent"],
+                                 params["width"], params["height"]))
+        return meth(params["self"], bbox, params["renderer"])
+    return get_offset
+
+
+# for debugging use
+def _bbox_artist(*args, **kwargs):
+    if DEBUG:
+        mbbox_artist(*args, **kwargs)
+
+
+def _get_packed_offsets(widths, total, sep, mode="fixed"):
+    r"""
+    Pack boxes specified by their *widths*.
+
+    For simplicity of the description, the terminology used here assumes a
+    horizontal layout, but the function works equally for a vertical layout.
+
+    There are three packing *mode*\s:
+
+    - 'fixed': The elements are packed tight to the left with a spacing of
+      *sep* in between. If *total* is *None* the returned total will be the
+      right edge of the last box. A non-*None* total will be passed unchecked
+      to the output. In particular this means that right edge of the last
+      box may be further to the right than the returned total.
+
+    - 'expand': Distribute the boxes with equal spacing so that the left edge
+      of the first box is at 0, and the right edge of the last box is at
+      *total*. The parameter *sep* is ignored in this mode. A total of *None*
+      is accepted and considered equal to 1. The total is returned unchanged
+      (except for the conversion *None* to 1). If the total is smaller than
+      the sum of the widths, the laid out boxes will overlap.
+
+    - 'equal': If *total* is given, the total space is divided in N equal
+      ranges and each box is left-aligned within its subspace.
+      Otherwise (*total* is *None*), *sep* must be provided and each box is
+      left-aligned in its subspace of width ``(max(widths) + sep)``. The
+      total width is then calculated to be ``N * (max(widths) + sep)``.
+
+    Parameters
+    ----------
+    widths : list of float
+        Widths of boxes to be packed.
+    total : float or None
+        Intended total length. *None* if not used.
+    sep : float or None
+        Spacing between boxes.
+    mode : {'fixed', 'expand', 'equal'}
+        The packing mode.
+
+    Returns
+    -------
+    total : float
+        The total width needed to accommodate the laid out boxes.
+    offsets : array of float
+        The left offsets of the boxes.
+    """
+    _api.check_in_list(["fixed", "expand", "equal"], mode=mode)
+
+    if mode == "fixed":
+        offsets_ = np.cumsum([0] + [w + sep for w in widths])
+        offsets = offsets_[:-1]
+        if total is None:
+            total = offsets_[-1] - sep
+        return total, offsets
+
+    elif mode == "expand":
+        # This is a bit of a hack to avoid a TypeError when *total*
+        # is None and used in conjugation with tight layout.
+        if total is None:
+            total = 1
+        if len(widths) > 1:
+            sep = (total - sum(widths)) / (len(widths) - 1)
+        else:
+            sep = 0
+        offsets_ = np.cumsum([0] + [w + sep for w in widths])
+        offsets = offsets_[:-1]
+        return total, offsets
+
+    elif mode == "equal":
+        maxh = max(widths)
+        if total is None:
+            if sep is None:
+                raise ValueError("total and sep cannot both be None when "
+                                 "using layout mode 'equal'")
+            total = (maxh + sep) * len(widths)
+        else:
+            sep = total / len(widths) - maxh
+        offsets = (maxh + sep) * np.arange(len(widths))
+        return total, offsets
+
+
+def _get_aligned_offsets(yspans, height, align="baseline"):
+    """
+    Align boxes each specified by their ``(y0, y1)`` spans.
+
+    For simplicity of the description, the terminology used here assumes a
+    horizontal layout (i.e., vertical alignment), but the function works
+    equally for a vertical layout.
+
+    Parameters
+    ----------
+    yspans
+        List of (y0, y1) spans of boxes to be aligned.
+    height : float or None
+        Intended total height. If None, the maximum of the heights
+        (``y1 - y0``) in *yspans* is used.
+    align : {'baseline', 'left', 'top', 'right', 'bottom', 'center'}
+        The alignment anchor of the boxes.
+
+    Returns
+    -------
+    (y0, y1)
+        y range spanned by the packing.  If a *height* was originally passed
+        in, then for all alignments other than "baseline", a span of ``(0,
+        height)`` is used without checking that it is actually large enough).
+    descent
+        The descent of the packing.
+    offsets
+        The bottom offsets of the boxes.
+    """
+
+    _api.check_in_list(
+        ["baseline", "left", "top", "right", "bottom", "center"], align=align)
+    if height is None:
+        height = max(y1 - y0 for y0, y1 in yspans)
+
+    if align == "baseline":
+        yspan = (min(y0 for y0, y1 in yspans), max(y1 for y0, y1 in yspans))
+        offsets = [0] * len(yspans)
+    elif align in ["left", "bottom"]:
+        yspan = (0, height)
+        offsets = [-y0 for y0, y1 in yspans]
+    elif align in ["right", "top"]:
+        yspan = (0, height)
+        offsets = [height - y1 for y0, y1 in yspans]
+    elif align == "center":
+        yspan = (0, height)
+        offsets = [(height - (y1 - y0)) * .5 - y0 for y0, y1 in yspans]
+
+    return yspan, offsets
+
+
+class OffsetBox(martist.Artist):
+    """
+    The OffsetBox is a simple container artist.
+
+    The child artists are meant to be drawn at a relative position to its
+    parent.
+
+    Being an artist itself, all parameters are passed on to `.Artist`.
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args)
+        self._internal_update(kwargs)
+        # Clipping has not been implemented in the OffsetBox family, so
+        # disable the clip flag for consistency. It can always be turned back
+        # on to zero effect.
+        self.set_clip_on(False)
+        self._children = []
+        self._offset = (0, 0)
+
+    def set_figure(self, fig):
+        """
+        Set the `.Figure` for the `.OffsetBox` and all its children.
+
+        Parameters
+        ----------
+        fig : `~matplotlib.figure.Figure`
+        """
+        super().set_figure(fig)
+        for c in self.get_children():
+            c.set_figure(fig)
+
+    @martist.Artist.axes.setter
+    def axes(self, ax):
+        # TODO deal with this better
+        martist.Artist.axes.fset(self, ax)
+        for c in self.get_children():
+            if c is not None:
+                c.axes = ax
+
+    def contains(self, mouseevent):
+        """
+        Delegate the mouse event contains-check to the children.
+
+        As a container, the `.OffsetBox` does not respond itself to
+        mouseevents.
+
+        Parameters
+        ----------
+        mouseevent : `~matplotlib.backend_bases.MouseEvent`
+
+        Returns
+        -------
+        contains : bool
+            Whether any values are within the radius.
+        details : dict
+            An artist-specific dictionary of details of the event context,
+            such as which points are contained in the pick radius. See the
+            individual Artist subclasses for details.
+
+        See Also
+        --------
+        .Artist.contains
+        """
+        if self._different_canvas(mouseevent):
+            return False, {}
+        for c in self.get_children():
+            a, b = c.contains(mouseevent)
+            if a:
+                return a, b
+        return False, {}
+
+    def set_offset(self, xy):
+        """
+        Set the offset.
+
+        Parameters
+        ----------
+        xy : (float, float) or callable
+            The (x, y) coordinates of the offset in display units. These can
+            either be given explicitly as a tuple (x, y), or by providing a
+            function that converts the extent into the offset. This function
+            must have the signature::
+
+                def offset(width, height, xdescent, ydescent, renderer) \
+-> (float, float)
+        """
+        self._offset = xy
+        self.stale = True
+
+    @_compat_get_offset
+    def get_offset(self, bbox, renderer):
+        """
+        Return the offset as a tuple (x, y).
+
+        The extent parameters have to be provided to handle the case where the
+        offset is dynamically determined by a callable (see
+        `~.OffsetBox.set_offset`).
+
+        Parameters
+        ----------
+        bbox : `.Bbox`
+        renderer : `.RendererBase` subclass
+        """
+        return (
+            self._offset(bbox.width, bbox.height, -bbox.x0, -bbox.y0, renderer)
+            if callable(self._offset)
+            else self._offset)
+
+    def set_width(self, width):
+        """
+        Set the width of the box.
+
+        Parameters
+        ----------
+        width : float
+        """
+        self.width = width
+        self.stale = True
+
+    def set_height(self, height):
+        """
+        Set the height of the box.
+
+        Parameters
+        ----------
+        height : float
+        """
+        self.height = height
+        self.stale = True
+
+    def get_visible_children(self):
+        r"""Return a list of the visible child `.Artist`\s."""
+        return [c for c in self._children if c.get_visible()]
+
+    def get_children(self):
+        r"""Return a list of the child `.Artist`\s."""
+        return self._children
+
+    def _get_bbox_and_child_offsets(self, renderer):
+        """
+        Return the bbox of the offsetbox and the child offsets.
+
+        The bbox should satisfy ``x0 <= x1 and y0 <= y1``.
+
+        Parameters
+        ----------
+        renderer : `.RendererBase` subclass
+
+        Returns
+        -------
+        bbox
+        list of (xoffset, yoffset) pairs
+        """
+        raise NotImplementedError(
+            "get_bbox_and_offsets must be overridden in derived classes")
+
+    def get_bbox(self, renderer):
+        """Return the bbox of the offsetbox, ignoring parent offsets."""
+        bbox, offsets = self._get_bbox_and_child_offsets(renderer)
+        return bbox
+
+    def get_window_extent(self, renderer=None):
+        # docstring inherited
+        if renderer is None:
+            renderer = self.figure._get_renderer()
+        bbox = self.get_bbox(renderer)
+        try:  # Some subclasses redefine get_offset to take no args.
+            px, py = self.get_offset(bbox, renderer)
+        except TypeError:
+            px, py = self.get_offset()
+        return bbox.translated(px, py)
+
+    def draw(self, renderer):
+        """
+        Update the location of children if necessary and draw them
+        to the given *renderer*.
+        """
+        bbox, offsets = self._get_bbox_and_child_offsets(renderer)
+        px, py = self.get_offset(bbox, renderer)
+        for c, (ox, oy) in zip(self.get_visible_children(), offsets):
+            c.set_offset((px + ox, py + oy))
+            c.draw(renderer)
+        _bbox_artist(self, renderer, fill=False, props=dict(pad=0.))
+        self.stale = False
+
+
+class PackerBase(OffsetBox):
+    def __init__(self, pad=0., sep=0., width=None, height=None,
+                 align="baseline", mode="fixed", children=None):
+        """
+        Parameters
+        ----------
+        pad : float, default: 0.0
+            The boundary padding in points.
+
+        sep : float, default: 0.0
+            The spacing between items in points.
+
+        width, height : float, optional
+            Width and height of the container box in pixels, calculated if
+            *None*.
+
+        align : {'top', 'bottom', 'left', 'right', 'center', 'baseline'}, \
+default: 'baseline'
+            Alignment of boxes.
+
+        mode : {'fixed', 'expand', 'equal'}, default: 'fixed'
+            The packing mode.
+
+            - 'fixed' packs the given `.Artist`\\s tight with *sep* spacing.
+            - 'expand' uses the maximal available space to distribute the
+              artists with equal spacing in between.
+            - 'equal': Each artist an equal fraction of the available space
+              and is left-aligned (or top-aligned) therein.
+
+        children : list of `.Artist`
+            The artists to pack.
+
+        Notes
+        -----
+        *pad* and *sep* are in points and will be scaled with the renderer
+        dpi, while *width* and *height* are in pixels.
+        """
+        super().__init__()
+        self.height = height
+        self.width = width
+        self.sep = sep
+        self.pad = pad
+        self.mode = mode
+        self.align = align
+        self._children = children
+
+
+class VPacker(PackerBase):
+    """
+    VPacker packs its children vertically, automatically adjusting their
+    relative positions at draw time.
+    """
+
+    def _get_bbox_and_child_offsets(self, renderer):
+        # docstring inherited
+        dpicor = renderer.points_to_pixels(1.)
+        pad = self.pad * dpicor
+        sep = self.sep * dpicor
+
+        if self.width is not None:
+            for c in self.get_visible_children():
+                if isinstance(c, PackerBase) and c.mode == "expand":
+                    c.set_width(self.width)
+
+        bboxes = [c.get_bbox(renderer) for c in self.get_visible_children()]
+        (x0, x1), xoffsets = _get_aligned_offsets(
+            [bbox.intervalx for bbox in bboxes], self.width, self.align)
+        height, yoffsets = _get_packed_offsets(
+            [bbox.height for bbox in bboxes], self.height, sep, self.mode)
+
+        yoffsets = height - (yoffsets + [bbox.y1 for bbox in bboxes])
+        ydescent = yoffsets[0]
+        yoffsets = yoffsets - ydescent
+
+        return (
+            Bbox.from_bounds(x0, -ydescent, x1 - x0, height).padded(pad),
+            [*zip(xoffsets, yoffsets)])
+
+
+class HPacker(PackerBase):
+    """
+    HPacker packs its children horizontally, automatically adjusting their
+    relative positions at draw time.
+    """
+
+    def _get_bbox_and_child_offsets(self, renderer):
+        # docstring inherited
+        dpicor = renderer.points_to_pixels(1.)
+        pad = self.pad * dpicor
+        sep = self.sep * dpicor
+
+        bboxes = [c.get_bbox(renderer) for c in self.get_visible_children()]
+        if not bboxes:
+            return Bbox.from_bounds(0, 0, 0, 0).padded(pad), []
+
+        (y0, y1), yoffsets = _get_aligned_offsets(
+            [bbox.intervaly for bbox in bboxes], self.height, self.align)
+        width, xoffsets = _get_packed_offsets(
+            [bbox.width for bbox in bboxes], self.width, sep, self.mode)
+
+        x0 = bboxes[0].x0
+        xoffsets -= ([bbox.x0 for bbox in bboxes] - x0)
+
+        return (Bbox.from_bounds(x0, y0, width, y1 - y0).padded(pad),
+                [*zip(xoffsets, yoffsets)])
+
+
+class PaddedBox(OffsetBox):
+    """
+    A container to add a padding around an `.Artist`.
+
+    The `.PaddedBox` contains a `.FancyBboxPatch` that is used to visualize
+    it when rendering.
+    """
+
+    def __init__(self, child, pad=0., *, draw_frame=False, patch_attrs=None):
+        """
+        Parameters
+        ----------
+        child : `~matplotlib.artist.Artist`
+            The contained `.Artist`.
+        pad : float, default: 0.0
+            The padding in points. This will be scaled with the renderer dpi.
+            In contrast, *width* and *height* are in *pixels* and thus not
+            scaled.
+        draw_frame : bool
+            Whether to draw the contained `.FancyBboxPatch`.
+        patch_attrs : dict or None
+            Additional parameters passed to the contained `.FancyBboxPatch`.
+        """
+        super().__init__()
+        self.pad = pad
+        self._children = [child]
+        self.patch = FancyBboxPatch(
+            xy=(0.0, 0.0), width=1., height=1.,
+            facecolor='w', edgecolor='k',
+            mutation_scale=1,  # self.prop.get_size_in_points(),
+            snap=True,
+            visible=draw_frame,
+            boxstyle="square,pad=0",
+        )
+        if patch_attrs is not None:
+            self.patch.update(patch_attrs)
+
+    def _get_bbox_and_child_offsets(self, renderer):
+        # docstring inherited.
+        pad = self.pad * renderer.points_to_pixels(1.)
+        return (self._children[0].get_bbox(renderer).padded(pad), [(0, 0)])
+
+    def draw(self, renderer):
+        # docstring inherited
+        bbox, offsets = self._get_bbox_and_child_offsets(renderer)
+        px, py = self.get_offset(bbox, renderer)
+        for c, (ox, oy) in zip(self.get_visible_children(), offsets):
+            c.set_offset((px + ox, py + oy))
+
+        self.draw_frame(renderer)
+
+        for c in self.get_visible_children():
+            c.draw(renderer)
+
+        self.stale = False
+
+    def update_frame(self, bbox, fontsize=None):
+        self.patch.set_bounds(bbox.bounds)
+        if fontsize:
+            self.patch.set_mutation_scale(fontsize)
+        self.stale = True
+
+    def draw_frame(self, renderer):
+        # update the location and size of the legend
+        self.update_frame(self.get_window_extent(renderer))
+        self.patch.draw(renderer)
+
+
+class DrawingArea(OffsetBox):
+    """
+    The DrawingArea can contain any Artist as a child. The DrawingArea
+    has a fixed width and height. The position of children relative to
+    the parent is fixed. The children can be clipped at the
+    boundaries of the parent.
+    """
+
+    def __init__(self, width, height, xdescent=0., ydescent=0., clip=False):
+        """
+        Parameters
+        ----------
+        width, height : float
+            Width and height of the container box.
+        xdescent, ydescent : float
+            Descent of the box in x- and y-direction.
+        clip : bool
+            Whether to clip the children to the box.
+        """
+        super().__init__()
+        self.width = width
+        self.height = height
+        self.xdescent = xdescent
+        self.ydescent = ydescent
+        self._clip_children = clip
+        self.offset_transform = mtransforms.Affine2D()
+        self.dpi_transform = mtransforms.Affine2D()
+
+    @property
+    def clip_children(self):
+        """
+        If the children of this DrawingArea should be clipped
+        by DrawingArea bounding box.
+        """
+        return self._clip_children
+
+    @clip_children.setter
+    def clip_children(self, val):
+        self._clip_children = bool(val)
+        self.stale = True
+
+    def get_transform(self):
+        """
+        Return the `~matplotlib.transforms.Transform` applied to the children.
+        """
+        return self.dpi_transform + self.offset_transform
+
+    def set_transform(self, t):
+        """
+        set_transform is ignored.
+        """
+
+    def set_offset(self, xy):
+        """
+        Set the offset of the container.
+
+        Parameters
+        ----------
+        xy : (float, float)
+            The (x, y) coordinates of the offset in display units.
+        """
+        self._offset = xy
+        self.offset_transform.clear()
+        self.offset_transform.translate(xy[0], xy[1])
+        self.stale = True
+
+    def get_offset(self):
+        """Return offset of the container."""
+        return self._offset
+
+    def get_bbox(self, renderer):
+        # docstring inherited
+        dpi_cor = renderer.points_to_pixels(1.)
+        return Bbox.from_bounds(
+            -self.xdescent * dpi_cor, -self.ydescent * dpi_cor,
+            self.width * dpi_cor, self.height * dpi_cor)
+
+    def add_artist(self, a):
+        """Add an `.Artist` to the container box."""
+        self._children.append(a)
+        if not a.is_transform_set():
+            a.set_transform(self.get_transform())
+        if self.axes is not None:
+            a.axes = self.axes
+        fig = self.figure
+        if fig is not None:
+            a.set_figure(fig)
+
+    def draw(self, renderer):
+        # docstring inherited
+
+        dpi_cor = renderer.points_to_pixels(1.)
+        self.dpi_transform.clear()
+        self.dpi_transform.scale(dpi_cor)
+
+        # At this point the DrawingArea has a transform
+        # to the display space so the path created is
+        # good for clipping children
+        tpath = mtransforms.TransformedPath(
+            mpath.Path([[0, 0], [0, self.height],
+                        [self.width, self.height],
+                        [self.width, 0]]),
+            self.get_transform())
+        for c in self._children:
+            if self._clip_children and not (c.clipbox or c._clippath):
+                c.set_clip_path(tpath)
+            c.draw(renderer)
+
+        _bbox_artist(self, renderer, fill=False, props=dict(pad=0.))
+        self.stale = False
+
+
+class TextArea(OffsetBox):
+    """
+    The TextArea is a container artist for a single Text instance.
+
+    The text is placed at (0, 0) with baseline+left alignment, by default. The
+    width and height of the TextArea instance is the width and height of its
+    child text.
+    """
+
+    def __init__(self, s,
+                 *,
+                 textprops=None,
+                 multilinebaseline=False,
+                 ):
+        """
+        Parameters
+        ----------
+        s : str
+            The text to be displayed.
+        textprops : dict, default: {}
+            Dictionary of keyword parameters to be passed to the `.Text`
+            instance in the TextArea.
+        multilinebaseline : bool, default: False
+            Whether the baseline for multiline text is adjusted so that it
+            is (approximately) center-aligned with single-line text.
+        """
+        if textprops is None:
+            textprops = {}
+        self._text = mtext.Text(0, 0, s, **textprops)
+        super().__init__()
+        self._children = [self._text]
+        self.offset_transform = mtransforms.Affine2D()
+        self._baseline_transform = mtransforms.Affine2D()
+        self._text.set_transform(self.offset_transform +
+                                 self._baseline_transform)
+        self._multilinebaseline = multilinebaseline
+
+    def set_text(self, s):
+        """Set the text of this area as a string."""
+        self._text.set_text(s)
+        self.stale = True
+
+    def get_text(self):
+        """Return the string representation of this area's text."""
+        return self._text.get_text()
+
+    def set_multilinebaseline(self, t):
+        """
+        Set multilinebaseline.
+
+        If True, the baseline for multiline text is adjusted so that it is
+        (approximately) center-aligned with single-line text.  This is used
+        e.g. by the legend implementation so that single-line labels are
+        baseline-aligned, but multiline labels are "center"-aligned with them.
+        """
+        self._multilinebaseline = t
+        self.stale = True
+
+    def get_multilinebaseline(self):
+        """
+        Get multilinebaseline.
+        """
+        return self._multilinebaseline
+
+    def set_transform(self, t):
+        """
+        set_transform is ignored.
+        """
+
+    def set_offset(self, xy):
+        """
+        Set the offset of the container.
+
+        Parameters
+        ----------
+        xy : (float, float)
+            The (x, y) coordinates of the offset in display units.
+        """
+        self._offset = xy
+        self.offset_transform.clear()
+        self.offset_transform.translate(xy[0], xy[1])
+        self.stale = True
+
+    def get_offset(self):
+        """Return offset of the container."""
+        return self._offset
+
+    def get_bbox(self, renderer):
+        _, h_, d_ = renderer.get_text_width_height_descent(
+            "lp", self._text._fontproperties,
+            ismath="TeX" if self._text.get_usetex() else False)
+
+        bbox, info, yd = self._text._get_layout(renderer)
+        w, h = bbox.size
+
+        self._baseline_transform.clear()
+
+        if len(info) > 1 and self._multilinebaseline:
+            yd_new = 0.5 * h - 0.5 * (h_ - d_)
+            self._baseline_transform.translate(0, yd - yd_new)
+            yd = yd_new
+        else:  # single line
+            h_d = max(h_ - d_, h - yd)
+            h = h_d + yd
+
+        ha = self._text.get_horizontalalignment()
+        x0 = {"left": 0, "center": -w / 2, "right": -w}[ha]
+
+        return Bbox.from_bounds(x0, -yd, w, h)
+
+    def draw(self, renderer):
+        # docstring inherited
+        self._text.draw(renderer)
+        _bbox_artist(self, renderer, fill=False, props=dict(pad=0.))
+        self.stale = False
+
+
+class AuxTransformBox(OffsetBox):
+    """
+    Offset Box with the aux_transform. Its children will be
+    transformed with the aux_transform first then will be
+    offsetted. The absolute coordinate of the aux_transform is meaning
+    as it will be automatically adjust so that the left-lower corner
+    of the bounding box of children will be set to (0, 0) before the
+    offset transform.
+
+    It is similar to drawing area, except that the extent of the box
+    is not predetermined but calculated from the window extent of its
+    children. Furthermore, the extent of the children will be
+    calculated in the transformed coordinate.
+    """
+    def __init__(self, aux_transform):
+        self.aux_transform = aux_transform
+        super().__init__()
+        self.offset_transform = mtransforms.Affine2D()
+        # ref_offset_transform makes offset_transform always relative to the
+        # lower-left corner of the bbox of its children.
+        self.ref_offset_transform = mtransforms.Affine2D()
+
+    def add_artist(self, a):
+        """Add an `.Artist` to the container box."""
+        self._children.append(a)
+        a.set_transform(self.get_transform())
+        self.stale = True
+
+    def get_transform(self):
+        """
+        Return the :class:`~matplotlib.transforms.Transform` applied
+        to the children
+        """
+        return (self.aux_transform
+                + self.ref_offset_transform
+                + self.offset_transform)
+
+    def set_transform(self, t):
+        """
+        set_transform is ignored.
+        """
+
+    def set_offset(self, xy):
+        """
+        Set the offset of the container.
+
+        Parameters
+        ----------
+        xy : (float, float)
+            The (x, y) coordinates of the offset in display units.
+        """
+        self._offset = xy
+        self.offset_transform.clear()
+        self.offset_transform.translate(xy[0], xy[1])
+        self.stale = True
+
+    def get_offset(self):
+        """Return offset of the container."""
+        return self._offset
+
+    def get_bbox(self, renderer):
+        # clear the offset transforms
+        _off = self.offset_transform.get_matrix()  # to be restored later
+        self.ref_offset_transform.clear()
+        self.offset_transform.clear()
+        # calculate the extent
+        bboxes = [c.get_window_extent(renderer) for c in self._children]
+        ub = Bbox.union(bboxes)
+        # adjust ref_offset_transform
+        self.ref_offset_transform.translate(-ub.x0, -ub.y0)
+        # restore offset transform
+        self.offset_transform.set_matrix(_off)
+        return Bbox.from_bounds(0, 0, ub.width, ub.height)
+
+    def draw(self, renderer):
+        # docstring inherited
+        for c in self._children:
+            c.draw(renderer)
+        _bbox_artist(self, renderer, fill=False, props=dict(pad=0.))
+        self.stale = False
+
+
+class AnchoredOffsetbox(OffsetBox):
+    """
+    An offset box placed according to location *loc*.
+
+    AnchoredOffsetbox has a single child.  When multiple children are needed,
+    use an extra OffsetBox to enclose them.  By default, the offset box is
+    anchored against its parent Axes. You may explicitly specify the
+    *bbox_to_anchor*.
+    """
+    zorder = 5  # zorder of the legend
+
+    # Location codes
+    codes = {'upper right': 1,
+             'upper left': 2,
+             'lower left': 3,
+             'lower right': 4,
+             'right': 5,
+             'center left': 6,
+             'center right': 7,
+             'lower center': 8,
+             'upper center': 9,
+             'center': 10,
+             }
+
+    def __init__(self, loc, *,
+                 pad=0.4, borderpad=0.5,
+                 child=None, prop=None, frameon=True,
+                 bbox_to_anchor=None,
+                 bbox_transform=None,
+                 **kwargs):
+        """
+        Parameters
+        ----------
+        loc : str
+            The box location.  Valid locations are
+            'upper left', 'upper center', 'upper right',
+            'center left', 'center', 'center right',
+            'lower left', 'lower center', 'lower right'.
+            For backward compatibility, numeric values are accepted as well.
+            See the parameter *loc* of `.Legend` for details.
+        pad : float, default: 0.4
+            Padding around the child as fraction of the fontsize.
+        borderpad : float, default: 0.5
+            Padding between the offsetbox frame and the *bbox_to_anchor*.
+        child : `.OffsetBox`
+            The box that will be anchored.
+        prop : `.FontProperties`
+            This is only used as a reference for paddings. If not given,
+            :rc:`legend.fontsize` is used.
+        frameon : bool
+            Whether to draw a frame around the box.
+        bbox_to_anchor : `.BboxBase`, 2-tuple, or 4-tuple of floats
+            Box that is used to position the legend in conjunction with *loc*.
+        bbox_transform : None or :class:`matplotlib.transforms.Transform`
+            The transform for the bounding box (*bbox_to_anchor*).
+        **kwargs
+            All other parameters are passed on to `.OffsetBox`.
+
+        Notes
+        -----
+        See `.Legend` for a detailed description of the anchoring mechanism.
+        """
+        super().__init__(**kwargs)
+
+        self.set_bbox_to_anchor(bbox_to_anchor, bbox_transform)
+        self.set_child(child)
+
+        if isinstance(loc, str):
+            loc = _api.check_getitem(self.codes, loc=loc)
+
+        self.loc = loc
+        self.borderpad = borderpad
+        self.pad = pad
+
+        if prop is None:
+            self.prop = FontProperties(size=mpl.rcParams["legend.fontsize"])
+        else:
+            self.prop = FontProperties._from_any(prop)
+            if isinstance(prop, dict) and "size" not in prop:
+                self.prop.set_size(mpl.rcParams["legend.fontsize"])
+
+        self.patch = FancyBboxPatch(
+            xy=(0.0, 0.0), width=1., height=1.,
+            facecolor='w', edgecolor='k',
+            mutation_scale=self.prop.get_size_in_points(),
+            snap=True,
+            visible=frameon,
+            boxstyle="square,pad=0",
+        )
+
+    def set_child(self, child):
+        """Set the child to be anchored."""
+        self._child = child
+        if child is not None:
+            child.axes = self.axes
+        self.stale = True
+
+    def get_child(self):
+        """Return the child."""
+        return self._child
+
+    def get_children(self):
+        """Return the list of children."""
+        return [self._child]
+
+    def get_bbox(self, renderer):
+        # docstring inherited
+        fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())
+        pad = self.pad * fontsize
+        return self.get_child().get_bbox(renderer).padded(pad)
+
+    def get_bbox_to_anchor(self):
+        """Return the bbox that the box is anchored to."""
+        if self._bbox_to_anchor is None:
+            return self.axes.bbox
+        else:
+            transform = self._bbox_to_anchor_transform
+            if transform is None:
+                return self._bbox_to_anchor
+            else:
+                return TransformedBbox(self._bbox_to_anchor, transform)
+
+    def set_bbox_to_anchor(self, bbox, transform=None):
+        """
+        Set the bbox that the box is anchored to.
+
+        *bbox* can be a Bbox instance, a list of [left, bottom, width,
+        height], or a list of [left, bottom] where the width and
+        height will be assumed to be zero. The bbox will be
+        transformed to display coordinate by the given transform.
+        """
+        if bbox is None or isinstance(bbox, BboxBase):
+            self._bbox_to_anchor = bbox
+        else:
+            try:
+                l = len(bbox)
+            except TypeError as err:
+                raise ValueError(f"Invalid bbox: {bbox}") from err
+
+            if l == 2:
+                bbox = [bbox[0], bbox[1], 0, 0]
+
+            self._bbox_to_anchor = Bbox.from_bounds(*bbox)
+
+        self._bbox_to_anchor_transform = transform
+        self.stale = True
+
+    @_compat_get_offset
+    def get_offset(self, bbox, renderer):
+        # docstring inherited
+        pad = (self.borderpad
+               * renderer.points_to_pixels(self.prop.get_size_in_points()))
+        bbox_to_anchor = self.get_bbox_to_anchor()
+        x0, y0 = _get_anchored_bbox(
+            self.loc, Bbox.from_bounds(0, 0, bbox.width, bbox.height),
+            bbox_to_anchor, pad)
+        return x0 - bbox.x0, y0 - bbox.y0
+
+    def update_frame(self, bbox, fontsize=None):
+        self.patch.set_bounds(bbox.bounds)
+        if fontsize:
+            self.patch.set_mutation_scale(fontsize)
+
+    def draw(self, renderer):
+        # docstring inherited
+        if not self.get_visible():
+            return
+
+        # update the location and size of the legend
+        bbox = self.get_window_extent(renderer)
+        fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())
+        self.update_frame(bbox, fontsize)
+        self.patch.draw(renderer)
+
+        px, py = self.get_offset(self.get_bbox(renderer), renderer)
+        self.get_child().set_offset((px, py))
+        self.get_child().draw(renderer)
+        self.stale = False
+
+
+def _get_anchored_bbox(loc, bbox, parentbbox, borderpad):
+    """
+    Return the (x, y) position of the *bbox* anchored at the *parentbbox* with
+    the *loc* code with the *borderpad*.
+    """
+    # This is only called internally and *loc* should already have been
+    # validated.  If 0 (None), we just let ``bbox.anchored`` raise.
+    c = [None, "NE", "NW", "SW", "SE", "E", "W", "E", "S", "N", "C"][loc]
+    container = parentbbox.padded(-borderpad)
+    return bbox.anchored(c, container=container).p0
+
+
+class AnchoredText(AnchoredOffsetbox):
+    """
+    AnchoredOffsetbox with Text.
+    """
+
+    def __init__(self, s, loc, *, pad=0.4, borderpad=0.5, prop=None, **kwargs):
+        """
+        Parameters
+        ----------
+        s : str
+            Text.
+
+        loc : str
+            Location code. See `AnchoredOffsetbox`.
+
+        pad : float, default: 0.4
+            Padding around the text as fraction of the fontsize.
+
+        borderpad : float, default: 0.5
+            Spacing between the offsetbox frame and the *bbox_to_anchor*.
+
+        prop : dict, optional
+            Dictionary of keyword parameters to be passed to the
+            `~matplotlib.text.Text` instance contained inside AnchoredText.
+
+        **kwargs
+            All other parameters are passed to `AnchoredOffsetbox`.
+        """
+
+        if prop is None:
+            prop = {}
+        badkwargs = {'va', 'verticalalignment'}
+        if badkwargs & set(prop):
+            raise ValueError(
+                'Mixing verticalalignment with AnchoredText is not supported.')
+
+        self.txt = TextArea(s, textprops=prop)
+        fp = self.txt._text.get_fontproperties()
+        super().__init__(
+            loc, pad=pad, borderpad=borderpad, child=self.txt, prop=fp,
+            **kwargs)
+
+
+class OffsetImage(OffsetBox):
+
+    def __init__(self, arr, *,
+                 zoom=1,
+                 cmap=None,
+                 norm=None,
+                 interpolation=None,
+                 origin=None,
+                 filternorm=True,
+                 filterrad=4.0,
+                 resample=False,
+                 dpi_cor=True,
+                 **kwargs
+                 ):
+
+        super().__init__()
+        self._dpi_cor = dpi_cor
+
+        self.image = BboxImage(bbox=self.get_window_extent,
+                               cmap=cmap,
+                               norm=norm,
+                               interpolation=interpolation,
+                               origin=origin,
+                               filternorm=filternorm,
+                               filterrad=filterrad,
+                               resample=resample,
+                               **kwargs
+                               )
+
+        self._children = [self.image]
+
+        self.set_zoom(zoom)
+        self.set_data(arr)
+
+    def set_data(self, arr):
+        self._data = np.asarray(arr)
+        self.image.set_data(self._data)
+        self.stale = True
+
+    def get_data(self):
+        return self._data
+
+    def set_zoom(self, zoom):
+        self._zoom = zoom
+        self.stale = True
+
+    def get_zoom(self):
+        return self._zoom
+
+    def get_offset(self):
+        """Return offset of the container."""
+        return self._offset
+
+    def get_children(self):
+        return [self.image]
+
+    def get_bbox(self, renderer):
+        dpi_cor = renderer.points_to_pixels(1.) if self._dpi_cor else 1.
+        zoom = self.get_zoom()
+        data = self.get_data()
+        ny, nx = data.shape[:2]
+        w, h = dpi_cor * nx * zoom, dpi_cor * ny * zoom
+        return Bbox.from_bounds(0, 0, w, h)
+
+    def draw(self, renderer):
+        # docstring inherited
+        self.image.draw(renderer)
+        # bbox_artist(self, renderer, fill=False, props=dict(pad=0.))
+        self.stale = False
+
+
+class AnnotationBbox(martist.Artist, mtext._AnnotationBase):
+    """
+    Container for an `OffsetBox` referring to a specific position *xy*.
+
+    Optionally an arrow pointing from the offsetbox to *xy* can be drawn.
+
+    This is like `.Annotation`, but with `OffsetBox` instead of `.Text`.
+    """
+
+    zorder = 3
+
+    def __str__(self):
+        return f"AnnotationBbox({self.xy[0]:g},{self.xy[1]:g})"
+
+    @_docstring.dedent_interpd
+    def __init__(self, offsetbox, xy, xybox=None, xycoords='data', boxcoords=None, *,
+                 frameon=True, pad=0.4,  # FancyBboxPatch boxstyle.
+                 annotation_clip=None,
+                 box_alignment=(0.5, 0.5),
+                 bboxprops=None,
+                 arrowprops=None,
+                 fontsize=None,
+                 **kwargs):
+        """
+        Parameters
+        ----------
+        offsetbox : `OffsetBox`
+
+        xy : (float, float)
+            The point *(x, y)* to annotate. The coordinate system is determined
+            by *xycoords*.
+
+        xybox : (float, float), default: *xy*
+            The position *(x, y)* to place the text at. The coordinate system
+            is determined by *boxcoords*.
+
+        xycoords : single or two-tuple of str or `.Artist` or `.Transform` or \
+callable, default: 'data'
+            The coordinate system that *xy* is given in. See the parameter
+            *xycoords* in `.Annotation` for a detailed description.
+
+        boxcoords : single or two-tuple of str or `.Artist` or `.Transform` \
+or callable, default: value of *xycoords*
+            The coordinate system that *xybox* is given in. See the parameter
+            *textcoords* in `.Annotation` for a detailed description.
+
+        frameon : bool, default: True
+            By default, the text is surrounded by a white `.FancyBboxPatch`
+            (accessible as the ``patch`` attribute of the `.AnnotationBbox`).
+            If *frameon* is set to False, this patch is made invisible.
+
+        annotation_clip: bool or None, default: None
+            Whether to clip (i.e. not draw) the annotation when the annotation
+            point *xy* is outside the Axes area.
+
+            - If *True*, the annotation will be clipped when *xy* is outside
+              the Axes.
+            - If *False*, the annotation will always be drawn.
+            - If *None*, the annotation will be clipped when *xy* is outside
+              the Axes and *xycoords* is 'data'.
+
+        pad : float, default: 0.4
+            Padding around the offsetbox.
+
+        box_alignment : (float, float)
+            A tuple of two floats for a vertical and horizontal alignment of
+            the offset box w.r.t. the *boxcoords*.
+            The lower-left corner is (0, 0) and upper-right corner is (1, 1).
+
+        bboxprops : dict, optional
+            A dictionary of properties to set for the annotation bounding box,
+            for example *boxstyle* and *alpha*.  See `.FancyBboxPatch` for
+            details.
+
+        arrowprops: dict, optional
+            Arrow properties, see `.Annotation` for description.
+
+        fontsize: float or str, optional
+            Translated to points and passed as *mutation_scale* into
+            `.FancyBboxPatch` to scale attributes of the box style (e.g. pad
+            or rounding_size).  The name is chosen in analogy to `.Text` where
+            *fontsize* defines the mutation scale as well.  If not given,
+            :rc:`legend.fontsize` is used.  See `.Text.set_fontsize` for valid
+            values.
+
+        **kwargs
+            Other `AnnotationBbox` properties.  See `.AnnotationBbox.set` for
+            a list.
+        """
+
+        martist.Artist.__init__(self)
+        mtext._AnnotationBase.__init__(
+            self, xy, xycoords=xycoords, annotation_clip=annotation_clip)
+
+        self.offsetbox = offsetbox
+        self.arrowprops = arrowprops.copy() if arrowprops is not None else None
+        self.set_fontsize(fontsize)
+        self.xybox = xybox if xybox is not None else xy
+        self.boxcoords = boxcoords if boxcoords is not None else xycoords
+        self._box_alignment = box_alignment
+
+        if arrowprops is not None:
+            self._arrow_relpos = self.arrowprops.pop("relpos", (0.5, 0.5))
+            self.arrow_patch = FancyArrowPatch((0, 0), (1, 1),
+                                               **self.arrowprops)
+        else:
+            self._arrow_relpos = None
+            self.arrow_patch = None
+
+        self.patch = FancyBboxPatch(  # frame
+            xy=(0.0, 0.0), width=1., height=1.,
+            facecolor='w', edgecolor='k',
+            mutation_scale=self.prop.get_size_in_points(),
+            snap=True,
+            visible=frameon,
+        )
+        self.patch.set_boxstyle("square", pad=pad)
+        if bboxprops:
+            self.patch.set(**bboxprops)
+
+        self._internal_update(kwargs)
+
+    @property
+    def xyann(self):
+        return self.xybox
+
+    @xyann.setter
+    def xyann(self, xyann):
+        self.xybox = xyann
+        self.stale = True
+
+    @property
+    def anncoords(self):
+        return self.boxcoords
+
+    @anncoords.setter
+    def anncoords(self, coords):
+        self.boxcoords = coords
+        self.stale = True
+
+    def contains(self, mouseevent):
+        if self._different_canvas(mouseevent):
+            return False, {}
+        if not self._check_xy(None):
+            return False, {}
+        return self.offsetbox.contains(mouseevent)
+        # self.arrow_patch is currently not checked as this can be a line - JJ
+
+    def get_children(self):
+        children = [self.offsetbox, self.patch]
+        if self.arrow_patch:
+            children.append(self.arrow_patch)
+        return children
+
+    def set_figure(self, fig):
+        if self.arrow_patch is not None:
+            self.arrow_patch.set_figure(fig)
+        self.offsetbox.set_figure(fig)
+        martist.Artist.set_figure(self, fig)
+
+    def set_fontsize(self, s=None):
+        """
+        Set the fontsize in points.
+
+        If *s* is not given, reset to :rc:`legend.fontsize`.
+        """
+        if s is None:
+            s = mpl.rcParams["legend.fontsize"]
+
+        self.prop = FontProperties(size=s)
+        self.stale = True
+
+    def get_fontsize(self):
+        """Return the fontsize in points."""
+        return self.prop.get_size_in_points()
+
+    def get_window_extent(self, renderer=None):
+        # docstring inherited
+        if renderer is None:
+            renderer = self.figure._get_renderer()
+        self.update_positions(renderer)
+        return Bbox.union([child.get_window_extent(renderer)
+                           for child in self.get_children()])
+
+    def get_tightbbox(self, renderer=None):
+        # docstring inherited
+        if renderer is None:
+            renderer = self.figure._get_renderer()
+        self.update_positions(renderer)
+        return Bbox.union([child.get_tightbbox(renderer)
+                           for child in self.get_children()])
+
+    def update_positions(self, renderer):
+        """Update pixel positions for the annotated point, the text, and the arrow."""
+
+        ox0, oy0 = self._get_xy(renderer, self.xybox, self.boxcoords)
+        bbox = self.offsetbox.get_bbox(renderer)
+        fw, fh = self._box_alignment
+        self.offsetbox.set_offset(
+            (ox0 - fw*bbox.width - bbox.x0, oy0 - fh*bbox.height - bbox.y0))
+
+        bbox = self.offsetbox.get_window_extent(renderer)
+        self.patch.set_bounds(bbox.bounds)
+
+        mutation_scale = renderer.points_to_pixels(self.get_fontsize())
+        self.patch.set_mutation_scale(mutation_scale)
+
+        if self.arrowprops:
+            # Use FancyArrowPatch if self.arrowprops has "arrowstyle" key.
+
+            # Adjust the starting point of the arrow relative to the textbox.
+            # TODO: Rotation needs to be accounted.
+            arrow_begin = bbox.p0 + bbox.size * self._arrow_relpos
+            arrow_end = self._get_position_xy(renderer)
+            # The arrow (from arrow_begin to arrow_end) will be first clipped
+            # by patchA and patchB, then shrunk by shrinkA and shrinkB (in
+            # points).  If patch A is not set, self.bbox_patch is used.
+            self.arrow_patch.set_positions(arrow_begin, arrow_end)
+
+            if "mutation_scale" in self.arrowprops:
+                mutation_scale = renderer.points_to_pixels(
+                    self.arrowprops["mutation_scale"])
+                # Else, use fontsize-based mutation_scale defined above.
+            self.arrow_patch.set_mutation_scale(mutation_scale)
+
+            patchA = self.arrowprops.get("patchA", self.patch)
+            self.arrow_patch.set_patchA(patchA)
+
+    def draw(self, renderer):
+        # docstring inherited
+        if not self.get_visible() or not self._check_xy(renderer):
+            return
+        renderer.open_group(self.__class__.__name__, gid=self.get_gid())
+        self.update_positions(renderer)
+        if self.arrow_patch is not None:
+            if self.arrow_patch.figure is None and self.figure is not None:
+                self.arrow_patch.figure = self.figure
+            self.arrow_patch.draw(renderer)
+        self.patch.draw(renderer)
+        self.offsetbox.draw(renderer)
+        renderer.close_group(self.__class__.__name__)
+        self.stale = False
+
+
+class DraggableBase:
+    """
+    Helper base class for a draggable artist (legend, offsetbox).
+
+    Derived classes must override the following methods::
+
+        def save_offset(self):
+            '''
+            Called when the object is picked for dragging; should save the
+            reference position of the artist.
+            '''
+
+        def update_offset(self, dx, dy):
+            '''
+            Called during the dragging; (*dx*, *dy*) is the pixel offset from
+            the point where the mouse drag started.
+            '''
+
+    Optionally, you may override the following method::
+
+        def finalize_offset(self):
+            '''Called when the mouse is released.'''
+
+    In the current implementation of `.DraggableLegend` and
+    `DraggableAnnotation`, `update_offset` places the artists in display
+    coordinates, and `finalize_offset` recalculates their position in axes
+    coordinate and set a relevant attribute.
+    """
+
+    def __init__(self, ref_artist, use_blit=False):
+        self.ref_artist = ref_artist
+        if not ref_artist.pickable():
+            ref_artist.set_picker(True)
+        self.got_artist = False
+        self._use_blit = use_blit and self.canvas.supports_blit
+        callbacks = self.canvas.callbacks
+        self._disconnectors = [
+            functools.partial(
+                callbacks.disconnect, callbacks._connect_picklable(name, func))
+            for name, func in [
+                ("pick_event", self.on_pick),
+                ("button_release_event", self.on_release),
+                ("motion_notify_event", self.on_motion),
+            ]
+        ]
+
+    # A property, not an attribute, to maintain picklability.
+    canvas = property(lambda self: self.ref_artist.figure.canvas)
+    cids = property(lambda self: [
+        disconnect.args[0] for disconnect in self._disconnectors[:2]])
+
+    def on_motion(self, evt):
+        if self._check_still_parented() and self.got_artist:
+            dx = evt.x - self.mouse_x
+            dy = evt.y - self.mouse_y
+            self.update_offset(dx, dy)
+            if self._use_blit:
+                self.canvas.restore_region(self.background)
+                self.ref_artist.draw(
+                    self.ref_artist.figure._get_renderer())
+                self.canvas.blit()
+            else:
+                self.canvas.draw()
+
+    def on_pick(self, evt):
+        if self._check_still_parented() and evt.artist == self.ref_artist:
+            self.mouse_x = evt.mouseevent.x
+            self.mouse_y = evt.mouseevent.y
+            self.got_artist = True
+            if self._use_blit:
+                self.ref_artist.set_animated(True)
+                self.canvas.draw()
+                self.background = \
+                    self.canvas.copy_from_bbox(self.ref_artist.figure.bbox)
+                self.ref_artist.draw(
+                    self.ref_artist.figure._get_renderer())
+                self.canvas.blit()
+            self.save_offset()
+
+    def on_release(self, event):
+        if self._check_still_parented() and self.got_artist:
+            self.finalize_offset()
+            self.got_artist = False
+            if self._use_blit:
+                self.ref_artist.set_animated(False)
+
+    def _check_still_parented(self):
+        if self.ref_artist.figure is None:
+            self.disconnect()
+            return False
+        else:
+            return True
+
+    def disconnect(self):
+        """Disconnect the callbacks."""
+        for disconnector in self._disconnectors:
+            disconnector()
+
+    def save_offset(self):
+        pass
+
+    def update_offset(self, dx, dy):
+        pass
+
+    def finalize_offset(self):
+        pass
+
+
+class DraggableOffsetBox(DraggableBase):
+    def __init__(self, ref_artist, offsetbox, use_blit=False):
+        super().__init__(ref_artist, use_blit=use_blit)
+        self.offsetbox = offsetbox
+
+    def save_offset(self):
+        offsetbox = self.offsetbox
+        renderer = offsetbox.figure._get_renderer()
+        offset = offsetbox.get_offset(offsetbox.get_bbox(renderer), renderer)
+        self.offsetbox_x, self.offsetbox_y = offset
+        self.offsetbox.set_offset(offset)
+
+    def update_offset(self, dx, dy):
+        loc_in_canvas = self.offsetbox_x + dx, self.offsetbox_y + dy
+        self.offsetbox.set_offset(loc_in_canvas)
+
+    def get_loc_in_canvas(self):
+        offsetbox = self.offsetbox
+        renderer = offsetbox.figure._get_renderer()
+        bbox = offsetbox.get_bbox(renderer)
+        ox, oy = offsetbox._offset
+        loc_in_canvas = (ox + bbox.x0, oy + bbox.y0)
+        return loc_in_canvas
+
+
+class DraggableAnnotation(DraggableBase):
+    def __init__(self, annotation, use_blit=False):
+        super().__init__(annotation, use_blit=use_blit)
+        self.annotation = annotation
+
+    def save_offset(self):
+        ann = self.annotation
+        self.ox, self.oy = ann.get_transform().transform(ann.xyann)
+
+    def update_offset(self, dx, dy):
+        ann = self.annotation
+        ann.xyann = ann.get_transform().inverted().transform(
+            (self.ox + dx, self.oy + dy))

llava_next/lib/python3.10/site-packages/matplotlib/patches.pyi

@@ -0,0 +1,755 @@
+from . import artist
+from .axes import Axes
+from .backend_bases import RendererBase, MouseEvent
+from .path import Path
+from .transforms import Transform, Bbox
+
+from typing import Any, Literal, overload
+
+import numpy as np
+from numpy.typing import ArrayLike
+from .typing import ColorType, LineStyleType, CapStyleType, JoinStyleType
+
+class Patch(artist.Artist):
+    zorder: float
+    def __init__(
+        self,
+        *,
+        edgecolor: ColorType | None = ...,
+        facecolor: ColorType | None = ...,
+        color: ColorType | None = ...,
+        linewidth: float | None = ...,
+        linestyle: LineStyleType | None = ...,
+        antialiased: bool | None = ...,
+        hatch: str | None = ...,
+        fill: bool = ...,
+        capstyle: CapStyleType | None = ...,
+        joinstyle: JoinStyleType | None = ...,
+        **kwargs,
+    ) -> None: ...
+    def get_verts(self) -> ArrayLike: ...
+    def contains(self, mouseevent: MouseEvent, radius: float | None = None) -> tuple[bool, dict[Any, Any]]: ...
+    def contains_point(
+        self, point: tuple[float, float], radius: float | None = ...
+    ) -> bool: ...
+    def contains_points(
+        self, points: ArrayLike, radius: float | None = ...
+    ) -> np.ndarray: ...
+    def get_extents(self) -> Bbox: ...
+    def get_transform(self) -> Transform: ...
+    def get_data_transform(self) -> Transform: ...
+    def get_patch_transform(self) -> Transform: ...
+    def get_antialiased(self) -> bool: ...
+    def get_edgecolor(self) -> ColorType: ...
+    def get_facecolor(self) -> ColorType: ...
+    def get_linewidth(self) -> float: ...
+    def get_linestyle(self) -> LineStyleType: ...
+    def set_antialiased(self, aa: bool | None) -> None: ...
+    def set_edgecolor(self, color: ColorType | None) -> None: ...
+    def set_facecolor(self, color: ColorType | None) -> None: ...
+    def set_color(self, c: ColorType | None) -> None: ...
+    def set_alpha(self, alpha: float | None) -> None: ...
+    def set_linewidth(self, w: float | None) -> None: ...
+    def set_linestyle(self, ls: LineStyleType | None) -> None: ...
+    def set_fill(self, b: bool) -> None: ...
+    def get_fill(self) -> bool: ...
+    fill = property(get_fill, set_fill)
+    def set_capstyle(self, s: CapStyleType) -> None: ...
+    def get_capstyle(self) -> Literal["butt", "projecting", "round"]: ...
+    def set_joinstyle(self, s: JoinStyleType) -> None: ...
+    def get_joinstyle(self) -> Literal["miter", "round", "bevel"]: ...
+    def set_hatch(self, hatch: str) -> None: ...
+    def get_hatch(self) -> str: ...
+    def get_path(self) -> Path: ...
+
+class Shadow(Patch):
+    patch: Patch
+    def __init__(self, patch: Patch, ox: float, oy: float, *, shade: float = ..., **kwargs) -> None: ...
+
+class Rectangle(Patch):
+    angle: float
+    def __init__(
+        self,
+        xy: tuple[float, float],
+        width: float,
+        height: float,
+        *,
+        angle: float = ...,
+        rotation_point: Literal["xy", "center"] | tuple[float, float] = ...,
+        **kwargs,
+    ) -> None: ...
+    @property
+    def rotation_point(self) -> Literal["xy", "center"] | tuple[float, float]: ...
+    @rotation_point.setter
+    def rotation_point(
+        self, value: Literal["xy", "center"] | tuple[float, float]
+    ) -> None: ...
+    def get_x(self) -> float: ...
+    def get_y(self) -> float: ...
+    def get_xy(self) -> tuple[float, float]: ...
+    def get_corners(self) -> np.ndarray: ...
+    def get_center(self) -> np.ndarray: ...
+    def get_width(self) -> float: ...
+    def get_height(self) -> float: ...
+    def get_angle(self) -> float: ...
+    def set_x(self, x: float) -> None: ...
+    def set_y(self, y: float) -> None: ...
+    def set_angle(self, angle: float) -> None: ...
+    def set_xy(self, xy: tuple[float, float]) -> None: ...
+    def set_width(self, w: float) -> None: ...
+    def set_height(self, h: float) -> None: ...
+    @overload
+    def set_bounds(self, args: tuple[float, float, float, float], /) -> None: ...
+    @overload
+    def set_bounds(
+        self, left: float, bottom: float, width: float, height: float, /
+    ) -> None: ...
+    def get_bbox(self) -> Bbox: ...
+    xy = property(get_xy, set_xy)
+
+class RegularPolygon(Patch):
+    xy: tuple[float, float]
+    numvertices: int
+    orientation: float
+    radius: float
+    def __init__(
+        self,
+        xy: tuple[float, float],
+        numVertices: int,
+        *,
+        radius: float = ...,
+        orientation: float = ...,
+        **kwargs,
+    ) -> None: ...
+
+class PathPatch(Patch):
+    def __init__(self, path: Path, **kwargs) -> None: ...
+    def set_path(self, path: Path) -> None: ...
+
+class StepPatch(PathPatch):
+    orientation: Literal["vertical", "horizontal"]
+    def __init__(
+        self,
+        values: ArrayLike,
+        edges: ArrayLike,
+        *,
+        orientation: Literal["vertical", "horizontal"] = ...,
+        baseline: float = ...,
+        **kwargs,
+    ) -> None: ...
+
+    # NamedTuple StairData, defined in body of method
+    def get_data(self) -> tuple[np.ndarray, np.ndarray, float]: ...
+    def set_data(
+        self,
+        values: ArrayLike | None = ...,
+        edges: ArrayLike | None = ...,
+        baseline: float | None = ...,
+    ) -> None: ...
+
+class Polygon(Patch):
+    def __init__(self, xy: ArrayLike, *, closed: bool = ..., **kwargs) -> None: ...
+    def get_closed(self) -> bool: ...
+    def set_closed(self, closed: bool) -> None: ...
+    def get_xy(self) -> np.ndarray: ...
+    def set_xy(self, xy: ArrayLike) -> None: ...
+    xy = property(get_xy, set_xy)
+
+class Wedge(Patch):
+    center: tuple[float, float]
+    r: float
+    theta1: float
+    theta2: float
+    width: float | None
+    def __init__(
+        self,
+        center: tuple[float, float],
+        r: float,
+        theta1: float,
+        theta2: float,
+        *,
+        width: float | None = ...,
+        **kwargs,
+    ) -> None: ...
+    def set_center(self, center: tuple[float, float]) -> None: ...
+    def set_radius(self, radius: float) -> None: ...
+    def set_theta1(self, theta1: float) -> None: ...
+    def set_theta2(self, theta2: float) -> None: ...
+    def set_width(self, width: float | None) -> None: ...
+
+class Arrow(Patch):
+    def __init__(
+        self, x: float, y: float, dx: float, dy: float, *, width: float = ..., **kwargs
+    ) -> None: ...
+    def set_data(
+        self,
+        x: float | None = ...,
+        y: float | None = ...,
+        dx: float | None = ...,
+        dy: float | None = ...,
+        width: float | None = ...,
+    ) -> None: ...
+class FancyArrow(Polygon):
+    def __init__(
+        self,
+        x: float,
+        y: float,
+        dx: float,
+        dy: float,
+        *,
+        width: float = ...,
+        length_includes_head: bool = ...,
+        head_width: float | None = ...,
+        head_length: float | None = ...,
+        shape: Literal["full", "left", "right"] = ...,
+        overhang: float = ...,
+        head_starts_at_zero: bool = ...,
+        **kwargs,
+    ) -> None: ...
+    def set_data(
+        self,
+        *,
+        x: float | None = ...,
+        y: float | None = ...,
+        dx: float | None = ...,
+        dy: float | None = ...,
+        width: float | None = ...,
+        head_width: float | None = ...,
+        head_length: float | None = ...,
+    ) -> None: ...
+
+class CirclePolygon(RegularPolygon):
+    def __init__(
+        self,
+        xy: tuple[float, float],
+        radius: float = ...,
+        *,
+        resolution: int = ...,
+        **kwargs,
+    ) -> None: ...
+
+class Ellipse(Patch):
+    def __init__(
+        self,
+        xy: tuple[float, float],
+        width: float,
+        height: float,
+        *,
+        angle: float = ...,
+        **kwargs,
+    ) -> None: ...
+    def set_center(self, xy: tuple[float, float]) -> None: ...
+    def get_center(self) -> float: ...
+    center = property(get_center, set_center)
+
+    def set_width(self, width: float) -> None: ...
+    def get_width(self) -> float: ...
+    width = property(get_width, set_width)
+
+    def set_height(self, height: float) -> None: ...
+    def get_height(self) -> float: ...
+    height = property(get_height, set_height)
+
+    def set_angle(self, angle: float) -> None: ...
+    def get_angle(self) -> float: ...
+    angle = property(get_angle, set_angle)
+
+    def get_corners(self) -> np.ndarray: ...
+
+    def get_vertices(self) -> list[tuple[float, float]]: ...
+    def get_co_vertices(self) -> list[tuple[float, float]]: ...
+
+
+class Annulus(Patch):
+    a: float
+    b: float
+    def __init__(
+        self,
+        xy: tuple[float, float],
+        r: float | tuple[float, float],
+        width: float,
+        angle: float = ...,
+        **kwargs,
+    ) -> None: ...
+    def set_center(self, xy: tuple[float, float]) -> None: ...
+    def get_center(self) -> tuple[float, float]: ...
+    center = property(get_center, set_center)
+
+    def set_width(self, width: float) -> None: ...
+    def get_width(self) -> float: ...
+    width = property(get_width, set_width)
+
+    def set_angle(self, angle: float) -> None: ...
+    def get_angle(self) -> float: ...
+    angle = property(get_angle, set_angle)
+
+    def set_semimajor(self, a: float) -> None: ...
+    def set_semiminor(self, b: float) -> None: ...
+    def set_radii(self, r: float | tuple[float, float]) -> None: ...
+    def get_radii(self) -> tuple[float, float]: ...
+    radii = property(get_radii, set_radii)
+
+class Circle(Ellipse):
+    def __init__(
+        self, xy: tuple[float, float], radius: float = ..., **kwargs
+    ) -> None: ...
+    def set_radius(self, radius: float) -> None: ...
+    def get_radius(self) -> float: ...
+    radius = property(get_radius, set_radius)
+
+class Arc(Ellipse):
+    theta1: float
+    theta2: float
+    def __init__(
+        self,
+        xy: tuple[float, float],
+        width: float,
+        height: float,
+        *,
+        angle: float = ...,
+        theta1: float = ...,
+        theta2: float = ...,
+        **kwargs,
+    ) -> None: ...
+
+def bbox_artist(
+    artist: artist.Artist,
+    renderer: RendererBase,
+    props: dict[str, Any] | None = ...,
+    fill: bool = ...,
+) -> None: ...
+def draw_bbox(
+    bbox: Bbox,
+    renderer: RendererBase,
+    color: ColorType = ...,
+    trans: Transform | None = ...,
+) -> None: ...
+
+class _Style:
+    def __new__(cls, stylename, **kwargs): ...
+    @classmethod
+    def get_styles(cls) -> dict[str, type]: ...
+    @classmethod
+    def pprint_styles(cls) -> str: ...
+    @classmethod
+    def register(cls, name: str, style: type) -> None: ...
+
+class BoxStyle(_Style):
+    class Square(BoxStyle):
+        pad: float
+        def __init__(self, pad: float = ...) -> None: ...
+        def __call__(
+            self,
+            x0: float,
+            y0: float,
+            width: float,
+            height: float,
+            mutation_size: float,
+        ) -> Path: ...
+
+    class Circle(BoxStyle):
+        pad: float
+        def __init__(self, pad: float = ...) -> None: ...
+        def __call__(
+            self,
+            x0: float,
+            y0: float,
+            width: float,
+            height: float,
+            mutation_size: float,
+        ) -> Path: ...
+
+    class Ellipse(BoxStyle):
+        pad: float
+        def __init__(self, pad: float = ...) -> None: ...
+        def __call__(
+            self,
+            x0: float,
+            y0: float,
+            width: float,
+            height: float,
+            mutation_size: float,
+        ) -> Path: ...
+
+    class LArrow(BoxStyle):
+        pad: float
+        def __init__(self, pad: float = ...) -> None: ...
+        def __call__(
+            self,
+            x0: float,
+            y0: float,
+            width: float,
+            height: float,
+            mutation_size: float,
+        ) -> Path: ...
+
+    class RArrow(LArrow):
+        def __call__(
+            self,
+            x0: float,
+            y0: float,
+            width: float,
+            height: float,
+            mutation_size: float,
+        ) -> Path: ...
+
+    class DArrow(BoxStyle):
+        pad: float
+        def __init__(self, pad: float = ...) -> None: ...
+        def __call__(
+            self,
+            x0: float,
+            y0: float,
+            width: float,
+            height: float,
+            mutation_size: float,
+        ) -> Path: ...
+
+    class Round(BoxStyle):
+        pad: float
+        rounding_size: float | None
+        def __init__(
+            self, pad: float = ..., rounding_size: float | None = ...
+        ) -> None: ...
+        def __call__(
+            self,
+            x0: float,
+            y0: float,
+            width: float,
+            height: float,
+            mutation_size: float,
+        ) -> Path: ...
+
+    class Round4(BoxStyle):
+        pad: float
+        rounding_size: float | None
+        def __init__(
+            self, pad: float = ..., rounding_size: float | None = ...
+        ) -> None: ...
+        def __call__(
+            self,
+            x0: float,
+            y0: float,
+            width: float,
+            height: float,
+            mutation_size: float,
+        ) -> Path: ...
+
+    class Sawtooth(BoxStyle):
+        pad: float
+        tooth_size: float | None
+        def __init__(
+            self, pad: float = ..., tooth_size: float | None = ...
+        ) -> None: ...
+        def __call__(
+            self,
+            x0: float,
+            y0: float,
+            width: float,
+            height: float,
+            mutation_size: float,
+        ) -> Path: ...
+
+    class Roundtooth(Sawtooth):
+        def __call__(
+            self,
+            x0: float,
+            y0: float,
+            width: float,
+            height: float,
+            mutation_size: float,
+        ) -> Path: ...
+
+class ConnectionStyle(_Style):
+    class _Base(ConnectionStyle):
+        def __call__(
+            self,
+            posA: tuple[float, float],
+            posB: tuple[float, float],
+            shrinkA: float = ...,
+            shrinkB: float = ...,
+            patchA: Patch | None = ...,
+            patchB: Patch | None = ...,
+        ) -> Path: ...
+
+    class Arc3(_Base):
+        rad: float
+        def __init__(self, rad: float = ...) -> None: ...
+        def connect(
+            self, posA: tuple[float, float], posB: tuple[float, float]
+        ) -> Path: ...
+
+    class Angle3(_Base):
+        angleA: float
+        angleB: float
+        def __init__(self, angleA: float = ..., angleB: float = ...) -> None: ...
+        def connect(
+            self, posA: tuple[float, float], posB: tuple[float, float]
+        ) -> Path: ...
+
+    class Angle(_Base):
+        angleA: float
+        angleB: float
+        rad: float
+        def __init__(
+            self, angleA: float = ..., angleB: float = ..., rad: float = ...
+        ) -> None: ...
+        def connect(
+            self, posA: tuple[float, float], posB: tuple[float, float]
+        ) -> Path: ...
+
+    class Arc(_Base):
+        angleA: float
+        angleB: float
+        armA: float | None
+        armB: float | None
+        rad: float
+        def __init__(
+            self,
+            angleA: float = ...,
+            angleB: float = ...,
+            armA: float | None = ...,
+            armB: float | None = ...,
+            rad: float = ...,
+        ) -> None: ...
+        def connect(
+            self, posA: tuple[float, float], posB: tuple[float, float]
+        ) -> Path: ...
+
+    class Bar(_Base):
+        armA: float
+        armB: float
+        fraction: float
+        angle: float | None
+        def __init__(
+            self,
+            armA: float = ...,
+            armB: float = ...,
+            fraction: float = ...,
+            angle: float | None = ...,
+        ) -> None: ...
+        def connect(
+            self, posA: tuple[float, float], posB: tuple[float, float]
+        ) -> Path: ...
+
+class ArrowStyle(_Style):
+    class _Base(ArrowStyle):
+        @staticmethod
+        def ensure_quadratic_bezier(path: Path) -> list[float]: ...
+        def transmute(
+            self, path: Path, mutation_size: float, linewidth: float
+        ) -> tuple[Path, bool]: ...
+        def __call__(
+            self,
+            path: Path,
+            mutation_size: float,
+            linewidth: float,
+            aspect_ratio: float = ...,
+        ) -> tuple[Path, bool]: ...
+
+    class _Curve(_Base):
+        arrow: str
+        fillbegin: bool
+        fillend: bool
+        def __init__(
+            self,
+            head_length: float = ...,
+            head_width: float = ...,
+            widthA: float = ...,
+            widthB: float = ...,
+            lengthA: float = ...,
+            lengthB: float = ...,
+            angleA: float | None = ...,
+            angleB: float | None = ...,
+            scaleA: float | None = ...,
+            scaleB: float | None = ...,
+        ) -> None: ...
+
+    class Curve(_Curve):
+        def __init__(self) -> None: ...
+
+    class CurveA(_Curve):
+        arrow: str
+
+    class CurveB(_Curve):
+        arrow: str
+
+    class CurveAB(_Curve):
+        arrow: str
+
+    class CurveFilledA(_Curve):
+        arrow: str
+
+    class CurveFilledB(_Curve):
+        arrow: str
+
+    class CurveFilledAB(_Curve):
+        arrow: str
+
+    class BracketA(_Curve):
+        arrow: str
+        def __init__(
+            self, widthA: float = ..., lengthA: float = ..., angleA: float = ...
+        ) -> None: ...
+
+    class BracketB(_Curve):
+        arrow: str
+        def __init__(
+            self, widthB: float = ..., lengthB: float = ..., angleB: float = ...
+        ) -> None: ...
+
+    class BracketAB(_Curve):
+        arrow: str
+        def __init__(
+            self,
+            widthA: float = ...,
+            lengthA: float = ...,
+            angleA: float = ...,
+            widthB: float = ...,
+            lengthB: float = ...,
+            angleB: float = ...,
+        ) -> None: ...
+
+    class BarAB(_Curve):
+        arrow: str
+        def __init__(
+            self,
+            widthA: float = ...,
+            angleA: float = ...,
+            widthB: float = ...,
+            angleB: float = ...,
+        ) -> None: ...
+
+    class BracketCurve(_Curve):
+        arrow: str
+        def __init__(
+            self, widthA: float = ..., lengthA: float = ..., angleA: float | None = ...
+        ) -> None: ...
+
+    class CurveBracket(_Curve):
+        arrow: str
+        def __init__(
+            self, widthB: float = ..., lengthB: float = ..., angleB: float | None = ...
+        ) -> None: ...
+
+    class Simple(_Base):
+        def __init__(
+            self,
+            head_length: float = ...,
+            head_width: float = ...,
+            tail_width: float = ...,
+        ) -> None: ...
+
+    class Fancy(_Base):
+        def __init__(
+            self,
+            head_length: float = ...,
+            head_width: float = ...,
+            tail_width: float = ...,
+        ) -> None: ...
+
+    class Wedge(_Base):
+        tail_width: float
+        shrink_factor: float
+        def __init__(
+            self, tail_width: float = ..., shrink_factor: float = ...
+        ) -> None: ...
+
+class FancyBboxPatch(Patch):
+    def __init__(
+        self,
+        xy: tuple[float, float],
+        width: float,
+        height: float,
+        boxstyle: str | BoxStyle = ...,
+        *,
+        mutation_scale: float = ...,
+        mutation_aspect: float = ...,
+        **kwargs,
+    ) -> None: ...
+    def set_boxstyle(self, boxstyle: str | BoxStyle | None = ..., **kwargs) -> None: ...
+    def get_boxstyle(self) -> BoxStyle: ...
+    def set_mutation_scale(self, scale: float) -> None: ...
+    def get_mutation_scale(self) -> float: ...
+    def set_mutation_aspect(self, aspect: float) -> None: ...
+    def get_mutation_aspect(self) -> float: ...
+    def get_x(self) -> float: ...
+    def get_y(self) -> float: ...
+    def get_width(self) -> float: ...
+    def get_height(self) -> float: ...
+    def set_x(self, x: float) -> None: ...
+    def set_y(self, y: float) -> None: ...
+    def set_width(self, w: float) -> None: ...
+    def set_height(self, h: float) -> None: ...
+    @overload
+    def set_bounds(self, args: tuple[float, float, float, float], /) -> None: ...
+    @overload
+    def set_bounds(
+        self, left: float, bottom: float, width: float, height: float, /
+    ) -> None: ...
+    def get_bbox(self) -> Bbox: ...
+
+class FancyArrowPatch(Patch):
+    patchA: Patch
+    patchB: Patch
+    shrinkA: float
+    shrinkB: float
+    def __init__(
+        self,
+        posA: tuple[float, float] | None = ...,
+        posB: tuple[float, float] | None = ...,
+        *,
+        path: Path | None = ...,
+        arrowstyle: str | ArrowStyle = ...,
+        connectionstyle: str | ConnectionStyle = ...,
+        patchA: Patch | None = ...,
+        patchB: Patch | None = ...,
+        shrinkA: float = ...,
+        shrinkB: float = ...,
+        mutation_scale: float = ...,
+        mutation_aspect: float | None = ...,
+        **kwargs,
+    ) -> None: ...
+    def set_positions(
+        self, posA: tuple[float, float], posB: tuple[float, float]
+    ) -> None: ...
+    def set_patchA(self, patchA: Patch) -> None: ...
+    def set_patchB(self, patchB: Patch) -> None: ...
+    def set_connectionstyle(self, connectionstyle: str | ConnectionStyle | None = ..., **kwargs) -> None: ...
+    def get_connectionstyle(self) -> ConnectionStyle: ...
+    def set_arrowstyle(self, arrowstyle: str | ArrowStyle | None = ..., **kwargs) -> None: ...
+    def get_arrowstyle(self) -> ArrowStyle: ...
+    def set_mutation_scale(self, scale: float) -> None: ...
+    def get_mutation_scale(self) -> float: ...
+    def set_mutation_aspect(self, aspect: float | None) -> None: ...
+    def get_mutation_aspect(self) -> float: ...
+
+class ConnectionPatch(FancyArrowPatch):
+    xy1: tuple[float, float]
+    xy2: tuple[float, float]
+    coords1: str | Transform
+    coords2: str | Transform | None
+    axesA: Axes | None
+    axesB: Axes | None
+    def __init__(
+        self,
+        xyA: tuple[float, float],
+        xyB: tuple[float, float],
+        coordsA: str | Transform,
+        coordsB: str | Transform | None = ...,
+        *,
+        axesA: Axes | None = ...,
+        axesB: Axes | None = ...,
+        arrowstyle: str | ArrowStyle = ...,
+        connectionstyle: str | ConnectionStyle = ...,
+        patchA: Patch | None = ...,
+        patchB: Patch | None = ...,
+        shrinkA: float = ...,
+        shrinkB: float = ...,
+        mutation_scale: float = ...,
+        mutation_aspect: float | None = ...,
+        clip_on: bool = ...,
+        **kwargs,
+    ) -> None: ...
+    def set_annotation_clip(self, b: bool | None) -> None: ...
+    def get_annotation_clip(self) -> bool | None: ...

llava_next/lib/python3.10/site-packages/matplotlib/path.pyi

@@ -0,0 +1,140 @@
+from .bezier import BezierSegment
+from .transforms import Affine2D, Transform, Bbox
+from collections.abc import Generator, Iterable, Sequence
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+from typing import Any, overload
+
+class Path:
+    code_type: type[np.uint8]
+    STOP: np.uint8
+    MOVETO: np.uint8
+    LINETO: np.uint8
+    CURVE3: np.uint8
+    CURVE4: np.uint8
+    CLOSEPOLY: np.uint8
+    NUM_VERTICES_FOR_CODE: dict[np.uint8, int]
+
+    def __init__(
+        self,
+        vertices: ArrayLike,
+        codes: ArrayLike | None = ...,
+        _interpolation_steps: int = ...,
+        closed: bool = ...,
+        readonly: bool = ...,
+    ) -> None: ...
+    @property
+    def vertices(self) -> ArrayLike: ...
+    @vertices.setter
+    def vertices(self, vertices: ArrayLike) -> None: ...
+    @property
+    def codes(self) -> ArrayLike | None: ...
+    @codes.setter
+    def codes(self, codes: ArrayLike) -> None: ...
+    @property
+    def simplify_threshold(self) -> float: ...
+    @simplify_threshold.setter
+    def simplify_threshold(self, threshold: float) -> None: ...
+    @property
+    def should_simplify(self) -> bool: ...
+    @should_simplify.setter
+    def should_simplify(self, should_simplify: bool) -> None: ...
+    @property
+    def readonly(self) -> bool: ...
+    def copy(self) -> Path: ...
+    def __deepcopy__(self, memo: dict[int, Any] | None = ...) -> Path: ...
+    deepcopy = __deepcopy__
+
+    @classmethod
+    def make_compound_path_from_polys(cls, XY: ArrayLike) -> Path: ...
+    @classmethod
+    def make_compound_path(cls, *args: Path) -> Path: ...
+    def __len__(self) -> int: ...
+    def iter_segments(
+        self,
+        transform: Transform | None = ...,
+        remove_nans: bool = ...,
+        clip: tuple[float, float, float, float] | None = ...,
+        snap: bool | None = ...,
+        stroke_width: float = ...,
+        simplify: bool | None = ...,
+        curves: bool = ...,
+        sketch: tuple[float, float, float] | None = ...,
+    ) -> Generator[tuple[np.ndarray, np.uint8], None, None]: ...
+    def iter_bezier(self, **kwargs) -> Generator[BezierSegment, None, None]: ...
+    def cleaned(
+        self,
+        transform: Transform | None = ...,
+        remove_nans: bool = ...,
+        clip: tuple[float, float, float, float] | None = ...,
+        *,
+        simplify: bool | None = ...,
+        curves: bool = ...,
+        stroke_width: float = ...,
+        snap: bool | None = ...,
+        sketch: tuple[float, float, float] | None = ...
+    ) -> Path: ...
+    def transformed(self, transform: Transform) -> Path: ...
+    def contains_point(
+        self,
+        point: tuple[float, float],
+        transform: Transform | None = ...,
+        radius: float = ...,
+    ) -> bool: ...
+    def contains_points(
+        self, points: ArrayLike, transform: Transform | None = ..., radius: float = ...
+    ) -> np.ndarray: ...
+    def contains_path(self, path: Path, transform: Transform | None = ...) -> bool: ...
+    def get_extents(self, transform: Transform | None = ..., **kwargs) -> Bbox: ...
+    def intersects_path(self, other: Path, filled: bool = ...) -> bool: ...
+    def intersects_bbox(self, bbox: Bbox, filled: bool = ...) -> bool: ...
+    def interpolated(self, steps: int) -> Path: ...
+    def to_polygons(
+        self,
+        transform: Transform | None = ...,
+        width: float = ...,
+        height: float = ...,
+        closed_only: bool = ...,
+    ) -> list[ArrayLike]: ...
+    @classmethod
+    def unit_rectangle(cls) -> Path: ...
+    @classmethod
+    def unit_regular_polygon(cls, numVertices: int) -> Path: ...
+    @classmethod
+    def unit_regular_star(cls, numVertices: int, innerCircle: float = ...) -> Path: ...
+    @classmethod
+    def unit_regular_asterisk(cls, numVertices: int) -> Path: ...
+    @classmethod
+    def unit_circle(cls) -> Path: ...
+    @classmethod
+    def circle(
+        cls,
+        center: tuple[float, float] = ...,
+        radius: float = ...,
+        readonly: bool = ...,
+    ) -> Path: ...
+    @classmethod
+    def unit_circle_righthalf(cls) -> Path: ...
+    @classmethod
+    def arc(
+        cls, theta1: float, theta2: float, n: int | None = ..., is_wedge: bool = ...
+    ) -> Path: ...
+    @classmethod
+    def wedge(cls, theta1: float, theta2: float, n: int | None = ...) -> Path: ...
+    @overload
+    @staticmethod
+    def hatch(hatchpattern: str, density: float = ...) -> Path: ...
+    @overload
+    @staticmethod
+    def hatch(hatchpattern: None, density: float = ...) -> None: ...
+    def clip_to_bbox(self, bbox: Bbox, inside: bool = ...) -> Path: ...
+
+def get_path_collection_extents(
+    master_transform: Transform,
+    paths: Sequence[Path],
+    transforms: Iterable[Affine2D],
+    offsets: ArrayLike,
+    offset_transform: Affine2D,
+) -> Bbox: ...

llava_next/lib/python3.10/site-packages/matplotlib/rcsetup.py

@@ -0,0 +1,1377 @@
+"""
+The rcsetup module contains the validation code for customization using
+Matplotlib's rc settings.
+
+Each rc setting is assigned a function used to validate any attempted changes
+to that setting.  The validation functions are defined in the rcsetup module,
+and are used to construct the rcParams global object which stores the settings
+and is referenced throughout Matplotlib.
+
+The default values of the rc settings are set in the default matplotlibrc file.
+Any additions or deletions to the parameter set listed here should also be
+propagated to the :file:`lib/matplotlib/mpl-data/matplotlibrc` in Matplotlib's
+root source directory.
+"""
+
+import ast
+from functools import lru_cache, reduce
+from numbers import Real
+import operator
+import os
+import re
+
+import numpy as np
+
+from matplotlib import _api, cbook
+from matplotlib.backends import BackendFilter, backend_registry
+from matplotlib.cbook import ls_mapper
+from matplotlib.colors import Colormap, is_color_like
+from matplotlib._fontconfig_pattern import parse_fontconfig_pattern
+from matplotlib._enums import JoinStyle, CapStyle
+
+# Don't let the original cycler collide with our validating cycler
+from cycler import Cycler, cycler as ccycler
+
+
+@_api.caching_module_getattr
+class __getattr__:
+    @_api.deprecated(
+        "3.9",
+        alternative="``matplotlib.backends.backend_registry.list_builtin"
+            "(matplotlib.backends.BackendFilter.INTERACTIVE)``")
+    @property
+    def interactive_bk(self):
+        return backend_registry.list_builtin(BackendFilter.INTERACTIVE)
+
+    @_api.deprecated(
+        "3.9",
+        alternative="``matplotlib.backends.backend_registry.list_builtin"
+            "(matplotlib.backends.BackendFilter.NON_INTERACTIVE)``")
+    @property
+    def non_interactive_bk(self):
+        return backend_registry.list_builtin(BackendFilter.NON_INTERACTIVE)
+
+    @_api.deprecated(
+        "3.9",
+        alternative="``matplotlib.backends.backend_registry.list_builtin()``")
+    @property
+    def all_backends(self):
+        return backend_registry.list_builtin()
+
+
+class ValidateInStrings:
+    def __init__(self, key, valid, ignorecase=False, *,
+                 _deprecated_since=None):
+        """*valid* is a list of legal strings."""
+        self.key = key
+        self.ignorecase = ignorecase
+        self._deprecated_since = _deprecated_since
+
+        def func(s):
+            if ignorecase:
+                return s.lower()
+            else:
+                return s
+        self.valid = {func(k): k for k in valid}
+
+    def __call__(self, s):
+        if self._deprecated_since:
+            name, = (k for k, v in globals().items() if v is self)
+            _api.warn_deprecated(
+                self._deprecated_since, name=name, obj_type="function")
+        if self.ignorecase and isinstance(s, str):
+            s = s.lower()
+        if s in self.valid:
+            return self.valid[s]
+        msg = (f"{s!r} is not a valid value for {self.key}; supported values "
+               f"are {[*self.valid.values()]}")
+        if (isinstance(s, str)
+                and (s.startswith('"') and s.endswith('"')
+                     or s.startswith("'") and s.endswith("'"))
+                and s[1:-1] in self.valid):
+            msg += "; remove quotes surrounding your string"
+        raise ValueError(msg)
+
+
+@lru_cache
+def _listify_validator(scalar_validator, allow_stringlist=False, *,
+                       n=None, doc=None):
+    def f(s):
+        if isinstance(s, str):
+            try:
+                val = [scalar_validator(v.strip()) for v in s.split(',')
+                       if v.strip()]
+            except Exception:
+                if allow_stringlist:
+                    # Sometimes, a list of colors might be a single string
+                    # of single-letter colornames. So give that a shot.
+                    val = [scalar_validator(v.strip()) for v in s if v.strip()]
+                else:
+                    raise
+        # Allow any ordered sequence type -- generators, np.ndarray, pd.Series
+        # -- but not sets, whose iteration order is non-deterministic.
+        elif np.iterable(s) and not isinstance(s, (set, frozenset)):
+            # The condition on this list comprehension will preserve the
+            # behavior of filtering out any empty strings (behavior was
+            # from the original validate_stringlist()), while allowing
+            # any non-string/text scalar values such as numbers and arrays.
+            val = [scalar_validator(v) for v in s
+                   if not isinstance(v, str) or v]
+        else:
+            raise ValueError(
+                f"Expected str or other non-set iterable, but got {s}")
+        if n is not None and len(val) != n:
+            raise ValueError(
+                f"Expected {n} values, but there are {len(val)} values in {s}")
+        return val
+
+    try:
+        f.__name__ = f"{scalar_validator.__name__}list"
+    except AttributeError:  # class instance.
+        f.__name__ = f"{type(scalar_validator).__name__}List"
+    f.__qualname__ = f.__qualname__.rsplit(".", 1)[0] + "." + f.__name__
+    f.__doc__ = doc if doc is not None else scalar_validator.__doc__
+    return f
+
+
+def validate_any(s):
+    return s
+validate_anylist = _listify_validator(validate_any)
+
+
+def _validate_date(s):
+    try:
+        np.datetime64(s)
+        return s
+    except ValueError:
+        raise ValueError(
+            f'{s!r} should be a string that can be parsed by numpy.datetime64')
+
+
+def validate_bool(b):
+    """Convert b to ``bool`` or raise."""
+    if isinstance(b, str):
+        b = b.lower()
+    if b in ('t', 'y', 'yes', 'on', 'true', '1', 1, True):
+        return True
+    elif b in ('f', 'n', 'no', 'off', 'false', '0', 0, False):
+        return False
+    else:
+        raise ValueError(f'Cannot convert {b!r} to bool')
+
+
+def validate_axisbelow(s):
+    try:
+        return validate_bool(s)
+    except ValueError:
+        if isinstance(s, str):
+            if s == 'line':
+                return 'line'
+    raise ValueError(f'{s!r} cannot be interpreted as'
+                     ' True, False, or "line"')
+
+
+def validate_dpi(s):
+    """Confirm s is string 'figure' or convert s to float or raise."""
+    if s == 'figure':
+        return s
+    try:
+        return float(s)
+    except ValueError as e:
+        raise ValueError(f'{s!r} is not string "figure" and '
+                         f'could not convert {s!r} to float') from e
+
+
+def _make_type_validator(cls, *, allow_none=False):
+    """
+    Return a validator that converts inputs to *cls* or raises (and possibly
+    allows ``None`` as well).
+    """
+
+    def validator(s):
+        if (allow_none and
+                (s is None or cbook._str_lower_equal(s, "none"))):
+            return None
+        if cls is str and not isinstance(s, str):
+            raise ValueError(f'Could not convert {s!r} to str')
+        try:
+            return cls(s)
+        except (TypeError, ValueError) as e:
+            raise ValueError(
+                f'Could not convert {s!r} to {cls.__name__}') from e
+
+    validator.__name__ = f"validate_{cls.__name__}"
+    if allow_none:
+        validator.__name__ += "_or_None"
+    validator.__qualname__ = (
+        validator.__qualname__.rsplit(".", 1)[0] + "." + validator.__name__)
+    return validator
+
+
+validate_string = _make_type_validator(str)
+validate_string_or_None = _make_type_validator(str, allow_none=True)
+validate_stringlist = _listify_validator(
+    validate_string, doc='return a list of strings')
+validate_int = _make_type_validator(int)
+validate_int_or_None = _make_type_validator(int, allow_none=True)
+validate_float = _make_type_validator(float)
+validate_float_or_None = _make_type_validator(float, allow_none=True)
+validate_floatlist = _listify_validator(
+    validate_float, doc='return a list of floats')
+
+
+def _validate_marker(s):
+    try:
+        return validate_int(s)
+    except ValueError as e:
+        try:
+            return validate_string(s)
+        except ValueError as e:
+            raise ValueError('Supported markers are [string, int]') from e
+
+
+_validate_markerlist = _listify_validator(
+    _validate_marker, doc='return a list of markers')
+
+
+def _validate_pathlike(s):
+    if isinstance(s, (str, os.PathLike)):
+        # Store value as str because savefig.directory needs to distinguish
+        # between "" (cwd) and "." (cwd, but gets updated by user selections).
+        return os.fsdecode(s)
+    else:
+        return validate_string(s)
+
+
+def validate_fonttype(s):
+    """
+    Confirm that this is a Postscript or PDF font type that we know how to
+    convert to.
+    """
+    fonttypes = {'type3':    3,
+                 'truetype': 42}
+    try:
+        fonttype = validate_int(s)
+    except ValueError:
+        try:
+            return fonttypes[s.lower()]
+        except KeyError as e:
+            raise ValueError('Supported Postscript/PDF font types are %s'
+                             % list(fonttypes)) from e
+    else:
+        if fonttype not in fonttypes.values():
+            raise ValueError(
+                'Supported Postscript/PDF font types are %s' %
+                list(fonttypes.values()))
+        return fonttype
+
+
+_auto_backend_sentinel = object()
+
+
+def validate_backend(s):
+    if s is _auto_backend_sentinel or backend_registry.is_valid_backend(s):
+        return s
+    else:
+        msg = (f"'{s}' is not a valid value for backend; supported values are "
+               f"{backend_registry.list_all()}")
+        raise ValueError(msg)
+
+
+def _validate_toolbar(s):
+    s = ValidateInStrings(
+        'toolbar', ['None', 'toolbar2', 'toolmanager'], ignorecase=True)(s)
+    if s == 'toolmanager':
+        _api.warn_external(
+            "Treat the new Tool classes introduced in v1.5 as experimental "
+            "for now; the API and rcParam may change in future versions.")
+    return s
+
+
+def validate_color_or_inherit(s):
+    """Return a valid color arg."""
+    if cbook._str_equal(s, 'inherit'):
+        return s
+    return validate_color(s)
+
+
+def validate_color_or_auto(s):
+    if cbook._str_equal(s, 'auto'):
+        return s
+    return validate_color(s)
+
+
+def validate_color_for_prop_cycle(s):
+    # N-th color cycle syntax can't go into the color cycle.
+    if isinstance(s, str) and re.match("^C[0-9]$", s):
+        raise ValueError(f"Cannot put cycle reference ({s!r}) in prop_cycler")
+    return validate_color(s)
+
+
+def _validate_color_or_linecolor(s):
+    if cbook._str_equal(s, 'linecolor'):
+        return s
+    elif cbook._str_equal(s, 'mfc') or cbook._str_equal(s, 'markerfacecolor'):
+        return 'markerfacecolor'
+    elif cbook._str_equal(s, 'mec') or cbook._str_equal(s, 'markeredgecolor'):
+        return 'markeredgecolor'
+    elif s is None:
+        return None
+    elif isinstance(s, str) and len(s) == 6 or len(s) == 8:
+        stmp = '#' + s
+        if is_color_like(stmp):
+            return stmp
+        if s.lower() == 'none':
+            return None
+    elif is_color_like(s):
+        return s
+
+    raise ValueError(f'{s!r} does not look like a color arg')
+
+
+def validate_color(s):
+    """Return a valid color arg."""
+    if isinstance(s, str):
+        if s.lower() == 'none':
+            return 'none'
+        if len(s) == 6 or len(s) == 8:
+            stmp = '#' + s
+            if is_color_like(stmp):
+                return stmp
+
+    if is_color_like(s):
+        return s
+
+    # If it is still valid, it must be a tuple (as a string from matplotlibrc).
+    try:
+        color = ast.literal_eval(s)
+    except (SyntaxError, ValueError):
+        pass
+    else:
+        if is_color_like(color):
+            return color
+
+    raise ValueError(f'{s!r} does not look like a color arg')
+
+
+validate_colorlist = _listify_validator(
+    validate_color, allow_stringlist=True, doc='return a list of colorspecs')
+
+
+def _validate_cmap(s):
+    _api.check_isinstance((str, Colormap), cmap=s)
+    return s
+
+
+def validate_aspect(s):
+    if s in ('auto', 'equal'):
+        return s
+    try:
+        return float(s)
+    except ValueError as e:
+        raise ValueError('not a valid aspect specification') from e
+
+
+def validate_fontsize_None(s):
+    if s is None or s == 'None':
+        return None
+    else:
+        return validate_fontsize(s)
+
+
+def validate_fontsize(s):
+    fontsizes = ['xx-small', 'x-small', 'small', 'medium', 'large',
+                 'x-large', 'xx-large', 'smaller', 'larger']
+    if isinstance(s, str):
+        s = s.lower()
+    if s in fontsizes:
+        return s
+    try:
+        return float(s)
+    except ValueError as e:
+        raise ValueError("%s is not a valid font size. Valid font sizes "
+                         "are %s." % (s, ", ".join(fontsizes))) from e
+
+
+validate_fontsizelist = _listify_validator(validate_fontsize)
+
+
+def validate_fontweight(s):
+    weights = [
+        'ultralight', 'light', 'normal', 'regular', 'book', 'medium', 'roman',
+        'semibold', 'demibold', 'demi', 'bold', 'heavy', 'extra bold', 'black']
+    # Note: Historically, weights have been case-sensitive in Matplotlib
+    if s in weights:
+        return s
+    try:
+        return int(s)
+    except (ValueError, TypeError) as e:
+        raise ValueError(f'{s} is not a valid font weight.') from e
+
+
+def validate_fontstretch(s):
+    stretchvalues = [
+        'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed',
+        'normal', 'semi-expanded', 'expanded', 'extra-expanded',
+        'ultra-expanded']
+    # Note: Historically, stretchvalues have been case-sensitive in Matplotlib
+    if s in stretchvalues:
+        return s
+    try:
+        return int(s)
+    except (ValueError, TypeError) as e:
+        raise ValueError(f'{s} is not a valid font stretch.') from e
+
+
+def validate_font_properties(s):
+    parse_fontconfig_pattern(s)
+    return s
+
+
+def _validate_mathtext_fallback(s):
+    _fallback_fonts = ['cm', 'stix', 'stixsans']
+    if isinstance(s, str):
+        s = s.lower()
+    if s is None or s == 'none':
+        return None
+    elif s.lower() in _fallback_fonts:
+        return s
+    else:
+        raise ValueError(
+            f"{s} is not a valid fallback font name. Valid fallback font "
+            f"names are {','.join(_fallback_fonts)}. Passing 'None' will turn "
+            "fallback off.")
+
+
+def validate_whiskers(s):
+    try:
+        return _listify_validator(validate_float, n=2)(s)
+    except (TypeError, ValueError):
+        try:
+            return float(s)
+        except ValueError as e:
+            raise ValueError("Not a valid whisker value [float, "
+                             "(float, float)]") from e
+
+
+def validate_ps_distiller(s):
+    if isinstance(s, str):
+        s = s.lower()
+    if s in ('none', None, 'false', False):
+        return None
+    else:
+        return ValidateInStrings('ps.usedistiller', ['ghostscript', 'xpdf'])(s)
+
+
+def _validate_papersize(s):
+    # Re-inline this validator when the 'auto' deprecation expires.
+    s = ValidateInStrings("ps.papersize",
+                          ["figure", "auto", "letter", "legal", "ledger",
+                           *[f"{ab}{i}" for ab in "ab" for i in range(11)]],
+                          ignorecase=True)(s)
+    if s == "auto":
+        _api.warn_deprecated("3.8", name="ps.papersize='auto'",
+                             addendum="Pass an explicit paper type, figure, or omit "
+                             "the *ps.papersize* rcParam entirely.")
+    return s
+
+
+# A validator dedicated to the named line styles, based on the items in
+# ls_mapper, and a list of possible strings read from Line2D.set_linestyle
+_validate_named_linestyle = ValidateInStrings(
+    'linestyle',
+    [*ls_mapper.keys(), *ls_mapper.values(), 'None', 'none', ' ', ''],
+    ignorecase=True)
+
+
+def _validate_linestyle(ls):
+    """
+    A validator for all possible line styles, the named ones *and*
+    the on-off ink sequences.
+    """
+    if isinstance(ls, str):
+        try:  # Look first for a valid named line style, like '--' or 'solid'.
+            return _validate_named_linestyle(ls)
+        except ValueError:
+            pass
+        try:
+            ls = ast.literal_eval(ls)  # Parsing matplotlibrc.
+        except (SyntaxError, ValueError):
+            pass  # Will error with the ValueError at the end.
+
+    def _is_iterable_not_string_like(x):
+        # Explicitly exclude bytes/bytearrays so that they are not
+        # nonsensically interpreted as sequences of numbers (codepoints).
+        return np.iterable(x) and not isinstance(x, (str, bytes, bytearray))
+
+    if _is_iterable_not_string_like(ls):
+        if len(ls) == 2 and _is_iterable_not_string_like(ls[1]):
+            # (offset, (on, off, on, off, ...))
+            offset, onoff = ls
+        else:
+            # For backcompat: (on, off, on, off, ...); the offset is implicit.
+            offset = 0
+            onoff = ls
+
+        if (isinstance(offset, Real)
+                and len(onoff) % 2 == 0
+                and all(isinstance(elem, Real) for elem in onoff)):
+            return (offset, onoff)
+
+    raise ValueError(f"linestyle {ls!r} is not a valid on-off ink sequence.")
+
+
+validate_fillstyle = ValidateInStrings(
+    'markers.fillstyle', ['full', 'left', 'right', 'bottom', 'top', 'none'])
+
+
+validate_fillstylelist = _listify_validator(validate_fillstyle)
+
+
+def validate_markevery(s):
+    """
+    Validate the markevery property of a Line2D object.
+
+    Parameters
+    ----------
+    s : None, int, (int, int), slice, float, (float, float), or list[int]
+
+    Returns
+    -------
+    None, int, (int, int), slice, float, (float, float), or list[int]
+    """
+    # Validate s against type slice float int and None
+    if isinstance(s, (slice, float, int, type(None))):
+        return s
+    # Validate s against type tuple
+    if isinstance(s, tuple):
+        if (len(s) == 2
+                and (all(isinstance(e, int) for e in s)
+                     or all(isinstance(e, float) for e in s))):
+            return s
+        else:
+            raise TypeError(
+                "'markevery' tuple must be pair of ints or of floats")
+    # Validate s against type list
+    if isinstance(s, list):
+        if all(isinstance(e, int) for e in s):
+            return s
+        else:
+            raise TypeError(
+                "'markevery' list must have all elements of type int")
+    raise TypeError("'markevery' is of an invalid type")
+
+
+validate_markeverylist = _listify_validator(validate_markevery)
+
+
+def validate_bbox(s):
+    if isinstance(s, str):
+        s = s.lower()
+        if s == 'tight':
+            return s
+        if s == 'standard':
+            return None
+        raise ValueError("bbox should be 'tight' or 'standard'")
+    elif s is not None:
+        # Backwards compatibility. None is equivalent to 'standard'.
+        raise ValueError("bbox should be 'tight' or 'standard'")
+    return s
+
+
+def validate_sketch(s):
+
+    if isinstance(s, str):
+        s = s.lower().strip()
+        if s.startswith("(") and s.endswith(")"):
+            s = s[1:-1]
+    if s == 'none' or s is None:
+        return None
+    try:
+        return tuple(_listify_validator(validate_float, n=3)(s))
+    except ValueError as exc:
+        raise ValueError("Expected a (scale, length, randomness) tuple") from exc
+
+
+def _validate_greaterthan_minushalf(s):
+    s = validate_float(s)
+    if s > -0.5:
+        return s
+    else:
+        raise RuntimeError(f'Value must be >-0.5; got {s}')
+
+
+def _validate_greaterequal0_lessequal1(s):
+    s = validate_float(s)
+    if 0 <= s <= 1:
+        return s
+    else:
+        raise RuntimeError(f'Value must be >=0 and <=1; got {s}')
+
+
+def _validate_int_greaterequal0(s):
+    s = validate_int(s)
+    if s >= 0:
+        return s
+    else:
+        raise RuntimeError(f'Value must be >=0; got {s}')
+
+
+def validate_hatch(s):
+    r"""
+    Validate a hatch pattern.
+    A hatch pattern string can have any sequence of the following
+    characters: ``\ / | - + * . x o O``.
+    """
+    if not isinstance(s, str):
+        raise ValueError("Hatch pattern must be a string")
+    _api.check_isinstance(str, hatch_pattern=s)
+    unknown = set(s) - {'\\', '/', '|', '-', '+', '*', '.', 'x', 'o', 'O'}
+    if unknown:
+        raise ValueError("Unknown hatch symbol(s): %s" % list(unknown))
+    return s
+
+
+validate_hatchlist = _listify_validator(validate_hatch)
+validate_dashlist = _listify_validator(validate_floatlist)
+
+
+def _validate_minor_tick_ndivs(n):
+    """
+    Validate ndiv parameter related to the minor ticks.
+    It controls the number of minor ticks to be placed between
+    two major ticks.
+    """
+
+    if cbook._str_lower_equal(n, 'auto'):
+        return n
+    try:
+        n = _validate_int_greaterequal0(n)
+        return n
+    except (RuntimeError, ValueError):
+        pass
+
+    raise ValueError("'tick.minor.ndivs' must be 'auto' or non-negative int")
+
+
+_prop_validators = {
+        'color': _listify_validator(validate_color_for_prop_cycle,
+                                    allow_stringlist=True),
+        'linewidth': validate_floatlist,
+        'linestyle': _listify_validator(_validate_linestyle),
+        'facecolor': validate_colorlist,
+        'edgecolor': validate_colorlist,
+        'joinstyle': _listify_validator(JoinStyle),
+        'capstyle': _listify_validator(CapStyle),
+        'fillstyle': validate_fillstylelist,
+        'markerfacecolor': validate_colorlist,
+        'markersize': validate_floatlist,
+        'markeredgewidth': validate_floatlist,
+        'markeredgecolor': validate_colorlist,
+        'markevery': validate_markeverylist,
+        'alpha': validate_floatlist,
+        'marker': _validate_markerlist,
+        'hatch': validate_hatchlist,
+        'dashes': validate_dashlist,
+    }
+_prop_aliases = {
+        'c': 'color',
+        'lw': 'linewidth',
+        'ls': 'linestyle',
+        'fc': 'facecolor',
+        'ec': 'edgecolor',
+        'mfc': 'markerfacecolor',
+        'mec': 'markeredgecolor',
+        'mew': 'markeredgewidth',
+        'ms': 'markersize',
+    }
+
+
+def cycler(*args, **kwargs):
+    """
+    Create a `~cycler.Cycler` object much like :func:`cycler.cycler`,
+    but includes input validation.
+
+    Call signatures::
+
+      cycler(cycler)
+      cycler(label=values[, label2=values2[, ...]])
+      cycler(label, values)
+
+    Form 1 copies a given `~cycler.Cycler` object.
+
+    Form 2 creates a `~cycler.Cycler` which cycles over one or more
+    properties simultaneously. If multiple properties are given, their
+    value lists must have the same length.
+
+    Form 3 creates a `~cycler.Cycler` for a single property. This form
+    exists for compatibility with the original cycler. Its use is
+    discouraged in favor of the kwarg form, i.e. ``cycler(label=values)``.
+
+    Parameters
+    ----------
+    cycler : Cycler
+        Copy constructor for Cycler.
+
+    label : str
+        The property key. Must be a valid `.Artist` property.
+        For example, 'color' or 'linestyle'. Aliases are allowed,
+        such as 'c' for 'color' and 'lw' for 'linewidth'.
+
+    values : iterable
+        Finite-length iterable of the property values. These values
+        are validated and will raise a ValueError if invalid.
+
+    Returns
+    -------
+    Cycler
+        A new :class:`~cycler.Cycler` for the given properties.
+
+    Examples
+    --------
+    Creating a cycler for a single property:
+
+    >>> c = cycler(color=['red', 'green', 'blue'])
+
+    Creating a cycler for simultaneously cycling over multiple properties
+    (e.g. red circle, green plus, blue cross):
+
+    >>> c = cycler(color=['red', 'green', 'blue'],
+    ...            marker=['o', '+', 'x'])
+
+    """
+    if args and kwargs:
+        raise TypeError("cycler() can only accept positional OR keyword "
+                        "arguments -- not both.")
+    elif not args and not kwargs:
+        raise TypeError("cycler() must have positional OR keyword arguments")
+
+    if len(args) == 1:
+        if not isinstance(args[0], Cycler):
+            raise TypeError("If only one positional argument given, it must "
+                            "be a Cycler instance.")
+        return validate_cycler(args[0])
+    elif len(args) == 2:
+        pairs = [(args[0], args[1])]
+    elif len(args) > 2:
+        raise _api.nargs_error('cycler', '0-2', len(args))
+    else:
+        pairs = kwargs.items()
+
+    validated = []
+    for prop, vals in pairs:
+        norm_prop = _prop_aliases.get(prop, prop)
+        validator = _prop_validators.get(norm_prop, None)
+        if validator is None:
+            raise TypeError("Unknown artist property: %s" % prop)
+        vals = validator(vals)
+        # We will normalize the property names as well to reduce
+        # the amount of alias handling code elsewhere.
+        validated.append((norm_prop, vals))
+
+    return reduce(operator.add, (ccycler(k, v) for k, v in validated))
+
+
+class _DunderChecker(ast.NodeVisitor):
+    def visit_Attribute(self, node):
+        if node.attr.startswith("__") and node.attr.endswith("__"):
+            raise ValueError("cycler strings with dunders are forbidden")
+        self.generic_visit(node)
+
+
+# A validator dedicated to the named legend loc
+_validate_named_legend_loc = ValidateInStrings(
+    'legend.loc',
+    [
+        "best",
+        "upper right", "upper left", "lower left", "lower right", "right",
+        "center left", "center right", "lower center", "upper center",
+        "center"],
+    ignorecase=True)
+
+
+def _validate_legend_loc(loc):
+    """
+    Confirm that loc is a type which rc.Params["legend.loc"] supports.
+
+    .. versionadded:: 3.8
+
+    Parameters
+    ----------
+    loc : str | int | (float, float) | str((float, float))
+        The location of the legend.
+
+    Returns
+    -------
+    loc : str | int | (float, float) or raise ValueError exception
+        The location of the legend.
+    """
+    if isinstance(loc, str):
+        try:
+            return _validate_named_legend_loc(loc)
+        except ValueError:
+            pass
+        try:
+            loc = ast.literal_eval(loc)
+        except (SyntaxError, ValueError):
+            pass
+    if isinstance(loc, int):
+        if 0 <= loc <= 10:
+            return loc
+    if isinstance(loc, tuple):
+        if len(loc) == 2 and all(isinstance(e, Real) for e in loc):
+            return loc
+    raise ValueError(f"{loc} is not a valid legend location.")
+
+
+def validate_cycler(s):
+    """Return a Cycler object from a string repr or the object itself."""
+    if isinstance(s, str):
+        # TODO: We might want to rethink this...
+        # While I think I have it quite locked down, it is execution of
+        # arbitrary code without sanitation.
+        # Combine this with the possibility that rcparams might come from the
+        # internet (future plans), this could be downright dangerous.
+        # I locked it down by only having the 'cycler()' function available.
+        # UPDATE: Partly plugging a security hole.
+        # I really should have read this:
+        # https://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html
+        # We should replace this eval with a combo of PyParsing and
+        # ast.literal_eval()
+        try:
+            _DunderChecker().visit(ast.parse(s))
+            s = eval(s, {'cycler': cycler, '__builtins__': {}})
+        except BaseException as e:
+            raise ValueError(f"{s!r} is not a valid cycler construction: {e}"
+                             ) from e
+    # Should make sure what comes from the above eval()
+    # is a Cycler object.
+    if isinstance(s, Cycler):
+        cycler_inst = s
+    else:
+        raise ValueError(f"Object is not a string or Cycler instance: {s!r}")
+
+    unknowns = cycler_inst.keys - (set(_prop_validators) | set(_prop_aliases))
+    if unknowns:
+        raise ValueError("Unknown artist properties: %s" % unknowns)
+
+    # Not a full validation, but it'll at least normalize property names
+    # A fuller validation would require v0.10 of cycler.
+    checker = set()
+    for prop in cycler_inst.keys:
+        norm_prop = _prop_aliases.get(prop, prop)
+        if norm_prop != prop and norm_prop in cycler_inst.keys:
+            raise ValueError(f"Cannot specify both {norm_prop!r} and alias "
+                             f"{prop!r} in the same prop_cycle")
+        if norm_prop in checker:
+            raise ValueError(f"Another property was already aliased to "
+                             f"{norm_prop!r}. Collision normalizing {prop!r}.")
+        checker.update([norm_prop])
+
+    # This is just an extra-careful check, just in case there is some
+    # edge-case I haven't thought of.
+    assert len(checker) == len(cycler_inst.keys)
+
+    # Now, it should be safe to mutate this cycler
+    for prop in cycler_inst.keys:
+        norm_prop = _prop_aliases.get(prop, prop)
+        cycler_inst.change_key(prop, norm_prop)
+
+    for key, vals in cycler_inst.by_key().items():
+        _prop_validators[key](vals)
+
+    return cycler_inst
+
+
+def validate_hist_bins(s):
+    valid_strs = ["auto", "sturges", "fd", "doane", "scott", "rice", "sqrt"]
+    if isinstance(s, str) and s in valid_strs:
+        return s
+    try:
+        return int(s)
+    except (TypeError, ValueError):
+        pass
+    try:
+        return validate_floatlist(s)
+    except ValueError:
+        pass
+    raise ValueError(f"'hist.bins' must be one of {valid_strs}, an int or"
+                     " a sequence of floats")
+
+
+class _ignorecase(list):
+    """A marker class indicating that a list-of-str is case-insensitive."""
+
+
+def _convert_validator_spec(key, conv):
+    if isinstance(conv, list):
+        ignorecase = isinstance(conv, _ignorecase)
+        return ValidateInStrings(key, conv, ignorecase=ignorecase)
+    else:
+        return conv
+
+
+# Mapping of rcParams to validators.
+# Converters given as lists or _ignorecase are converted to ValidateInStrings
+# immediately below.
+# The rcParams defaults are defined in lib/matplotlib/mpl-data/matplotlibrc, which
+# gets copied to matplotlib/mpl-data/matplotlibrc by the setup script.
+_validators = {
+    "backend":           validate_backend,
+    "backend_fallback":  validate_bool,
+    "figure.hooks":      validate_stringlist,
+    "toolbar":           _validate_toolbar,
+    "interactive":       validate_bool,
+    "timezone":          validate_string,
+
+    "webagg.port":            validate_int,
+    "webagg.address":         validate_string,
+    "webagg.open_in_browser": validate_bool,
+    "webagg.port_retries":    validate_int,
+
+    # line props
+    "lines.linewidth":       validate_float,  # line width in points
+    "lines.linestyle":       _validate_linestyle,  # solid line
+    "lines.color":           validate_color,  # first color in color cycle
+    "lines.marker":          _validate_marker,  # marker name
+    "lines.markerfacecolor": validate_color_or_auto,  # default color
+    "lines.markeredgecolor": validate_color_or_auto,  # default color
+    "lines.markeredgewidth": validate_float,
+    "lines.markersize":      validate_float,  # markersize, in points
+    "lines.antialiased":     validate_bool,  # antialiased (no jaggies)
+    "lines.dash_joinstyle":  JoinStyle,
+    "lines.solid_joinstyle": JoinStyle,
+    "lines.dash_capstyle":   CapStyle,
+    "lines.solid_capstyle":  CapStyle,
+    "lines.dashed_pattern":  validate_floatlist,
+    "lines.dashdot_pattern": validate_floatlist,
+    "lines.dotted_pattern":  validate_floatlist,
+    "lines.scale_dashes":    validate_bool,
+
+    # marker props
+    "markers.fillstyle": validate_fillstyle,
+
+    ## pcolor(mesh) props:
+    "pcolor.shading": ["auto", "flat", "nearest", "gouraud"],
+    "pcolormesh.snap": validate_bool,
+
+    ## patch props
+    "patch.linewidth":       validate_float,  # line width in points
+    "patch.edgecolor":       validate_color,
+    "patch.force_edgecolor": validate_bool,
+    "patch.facecolor":       validate_color,  # first color in cycle
+    "patch.antialiased":     validate_bool,  # antialiased (no jaggies)
+
+    ## hatch props
+    "hatch.color":     validate_color,
+    "hatch.linewidth": validate_float,
+
+    ## Histogram properties
+    "hist.bins": validate_hist_bins,
+
+    ## Boxplot properties
+    "boxplot.notch":       validate_bool,
+    "boxplot.vertical":    validate_bool,
+    "boxplot.whiskers":    validate_whiskers,
+    "boxplot.bootstrap":   validate_int_or_None,
+    "boxplot.patchartist": validate_bool,
+    "boxplot.showmeans":   validate_bool,
+    "boxplot.showcaps":    validate_bool,
+    "boxplot.showbox":     validate_bool,
+    "boxplot.showfliers":  validate_bool,
+    "boxplot.meanline":    validate_bool,
+
+    "boxplot.flierprops.color":           validate_color,
+    "boxplot.flierprops.marker":          _validate_marker,
+    "boxplot.flierprops.markerfacecolor": validate_color_or_auto,
+    "boxplot.flierprops.markeredgecolor": validate_color,
+    "boxplot.flierprops.markeredgewidth": validate_float,
+    "boxplot.flierprops.markersize":      validate_float,
+    "boxplot.flierprops.linestyle":       _validate_linestyle,
+    "boxplot.flierprops.linewidth":       validate_float,
+
+    "boxplot.boxprops.color":     validate_color,
+    "boxplot.boxprops.linewidth": validate_float,
+    "boxplot.boxprops.linestyle": _validate_linestyle,
+
+    "boxplot.whiskerprops.color":     validate_color,
+    "boxplot.whiskerprops.linewidth": validate_float,
+    "boxplot.whiskerprops.linestyle": _validate_linestyle,
+
+    "boxplot.capprops.color":     validate_color,
+    "boxplot.capprops.linewidth": validate_float,
+    "boxplot.capprops.linestyle": _validate_linestyle,
+
+    "boxplot.medianprops.color":     validate_color,
+    "boxplot.medianprops.linewidth": validate_float,
+    "boxplot.medianprops.linestyle": _validate_linestyle,
+
+    "boxplot.meanprops.color":           validate_color,
+    "boxplot.meanprops.marker":          _validate_marker,
+    "boxplot.meanprops.markerfacecolor": validate_color,
+    "boxplot.meanprops.markeredgecolor": validate_color,
+    "boxplot.meanprops.markersize":      validate_float,
+    "boxplot.meanprops.linestyle":       _validate_linestyle,
+    "boxplot.meanprops.linewidth":       validate_float,
+
+    ## font props
+    "font.family":     validate_stringlist,  # used by text object
+    "font.style":      validate_string,
+    "font.variant":    validate_string,
+    "font.stretch":    validate_fontstretch,
+    "font.weight":     validate_fontweight,
+    "font.size":       validate_float,  # Base font size in points
+    "font.serif":      validate_stringlist,
+    "font.sans-serif": validate_stringlist,
+    "font.cursive":    validate_stringlist,
+    "font.fantasy":    validate_stringlist,
+    "font.monospace":  validate_stringlist,
+
+    # text props
+    "text.color":          validate_color,
+    "text.usetex":         validate_bool,
+    "text.latex.preamble": validate_string,
+    "text.hinting":        ["default", "no_autohint", "force_autohint",
+                            "no_hinting", "auto", "native", "either", "none"],
+    "text.hinting_factor": validate_int,
+    "text.kerning_factor": validate_int,
+    "text.antialiased":    validate_bool,
+    "text.parse_math":     validate_bool,
+
+    "mathtext.cal":            validate_font_properties,
+    "mathtext.rm":             validate_font_properties,
+    "mathtext.tt":             validate_font_properties,
+    "mathtext.it":             validate_font_properties,
+    "mathtext.bf":             validate_font_properties,
+    "mathtext.bfit":           validate_font_properties,
+    "mathtext.sf":             validate_font_properties,
+    "mathtext.fontset":        ["dejavusans", "dejavuserif", "cm", "stix",
+                                "stixsans", "custom"],
+    "mathtext.default":        ["rm", "cal", "bfit", "it", "tt", "sf", "bf", "default",
+                                "bb", "frak", "scr", "regular"],
+    "mathtext.fallback":       _validate_mathtext_fallback,
+
+    "image.aspect":              validate_aspect,  # equal, auto, a number
+    "image.interpolation":       validate_string,
+    "image.interpolation_stage": ["data", "rgba"],
+    "image.cmap":                _validate_cmap,  # gray, jet, etc.
+    "image.lut":                 validate_int,  # lookup table
+    "image.origin":              ["upper", "lower"],
+    "image.resample":            validate_bool,
+    # Specify whether vector graphics backends will combine all images on a
+    # set of Axes into a single composite image
+    "image.composite_image": validate_bool,
+
+    # contour props
+    "contour.negative_linestyle": _validate_linestyle,
+    "contour.corner_mask":        validate_bool,
+    "contour.linewidth":          validate_float_or_None,
+    "contour.algorithm":          ["mpl2005", "mpl2014", "serial", "threaded"],
+
+    # errorbar props
+    "errorbar.capsize": validate_float,
+
+    # axis props
+    # alignment of x/y axis title
+    "xaxis.labellocation": ["left", "center", "right"],
+    "yaxis.labellocation": ["bottom", "center", "top"],
+
+    # Axes props
+    "axes.axisbelow":        validate_axisbelow,
+    "axes.facecolor":        validate_color,  # background color
+    "axes.edgecolor":        validate_color,  # edge color
+    "axes.linewidth":        validate_float,  # edge linewidth
+
+    "axes.spines.left":      validate_bool,  # Set visibility of axes spines,
+    "axes.spines.right":     validate_bool,  # i.e., the lines around the chart
+    "axes.spines.bottom":    validate_bool,  # denoting data boundary.
+    "axes.spines.top":       validate_bool,
+
+    "axes.titlesize":     validate_fontsize,  # Axes title fontsize
+    "axes.titlelocation": ["left", "center", "right"],  # Axes title alignment
+    "axes.titleweight":   validate_fontweight,  # Axes title font weight
+    "axes.titlecolor":    validate_color_or_auto,  # Axes title font color
+    # title location, axes units, None means auto
+    "axes.titley":        validate_float_or_None,
+    # pad from Axes top decoration to title in points
+    "axes.titlepad":      validate_float,
+    "axes.grid":          validate_bool,  # display grid or not
+    "axes.grid.which":    ["minor", "both", "major"],  # which grids are drawn
+    "axes.grid.axis":     ["x", "y", "both"],  # grid type
+    "axes.labelsize":     validate_fontsize,  # fontsize of x & y labels
+    "axes.labelpad":      validate_float,  # space between label and axis
+    "axes.labelweight":   validate_fontweight,  # fontsize of x & y labels
+    "axes.labelcolor":    validate_color,  # color of axis label
+    # use scientific notation if log10 of the axis range is smaller than the
+    # first or larger than the second
+    "axes.formatter.limits": _listify_validator(validate_int, n=2),
+    # use current locale to format ticks
+    "axes.formatter.use_locale": validate_bool,
+    "axes.formatter.use_mathtext": validate_bool,
+    # minimum exponent to format in scientific notation
+    "axes.formatter.min_exponent": validate_int,
+    "axes.formatter.useoffset": validate_bool,
+    "axes.formatter.offset_threshold": validate_int,
+    "axes.unicode_minus": validate_bool,
+    # This entry can be either a cycler object or a string repr of a
+    # cycler-object, which gets eval()'ed to create the object.
+    "axes.prop_cycle": validate_cycler,
+    # If "data", axes limits are set close to the data.
+    # If "round_numbers" axes limits are set to the nearest round numbers.
+    "axes.autolimit_mode": ["data", "round_numbers"],
+    "axes.xmargin": _validate_greaterthan_minushalf,  # margin added to xaxis
+    "axes.ymargin": _validate_greaterthan_minushalf,  # margin added to yaxis
+    "axes.zmargin": _validate_greaterthan_minushalf,  # margin added to zaxis
+
+    "polaraxes.grid":    validate_bool,  # display polar grid or not
+    "axes3d.grid":       validate_bool,  # display 3d grid
+    "axes3d.automargin": validate_bool,  # automatically add margin when
+                                         # manually setting 3D axis limits
+
+    "axes3d.xaxis.panecolor":    validate_color,  # 3d background pane
+    "axes3d.yaxis.panecolor":    validate_color,  # 3d background pane
+    "axes3d.zaxis.panecolor":    validate_color,  # 3d background pane
+
+    # scatter props
+    "scatter.marker":     _validate_marker,
+    "scatter.edgecolors": validate_string,
+
+    "date.epoch": _validate_date,
+    "date.autoformatter.year":        validate_string,
+    "date.autoformatter.month":       validate_string,
+    "date.autoformatter.day":         validate_string,
+    "date.autoformatter.hour":        validate_string,
+    "date.autoformatter.minute":      validate_string,
+    "date.autoformatter.second":      validate_string,
+    "date.autoformatter.microsecond": validate_string,
+
+    'date.converter':          ['auto', 'concise'],
+    # for auto date locator, choose interval_multiples
+    'date.interval_multiples': validate_bool,
+
+    # legend properties
+    "legend.fancybox": validate_bool,
+    "legend.loc": _validate_legend_loc,
+
+    # the number of points in the legend line
+    "legend.numpoints":      validate_int,
+    # the number of points in the legend line for scatter
+    "legend.scatterpoints":  validate_int,
+    "legend.fontsize":       validate_fontsize,
+    "legend.title_fontsize": validate_fontsize_None,
+    # color of the legend
+    "legend.labelcolor":     _validate_color_or_linecolor,
+    # the relative size of legend markers vs. original
+    "legend.markerscale":    validate_float,
+    # using dict in rcParams not yet supported, so make sure it is bool
+    "legend.shadow":         validate_bool,
+    # whether or not to draw a frame around legend
+    "legend.frameon":        validate_bool,
+    # alpha value of the legend frame
+    "legend.framealpha":     validate_float_or_None,
+
+    ## the following dimensions are in fraction of the font size
+    "legend.borderpad":      validate_float,  # units are fontsize
+    # the vertical space between the legend entries
+    "legend.labelspacing":   validate_float,
+    # the length of the legend lines
+    "legend.handlelength":   validate_float,
+    # the length of the legend lines
+    "legend.handleheight":   validate_float,
+    # the space between the legend line and legend text
+    "legend.handletextpad":  validate_float,
+    # the border between the Axes and legend edge
+    "legend.borderaxespad":  validate_float,
+    # the border between the Axes and legend edge
+    "legend.columnspacing":  validate_float,
+    "legend.facecolor":      validate_color_or_inherit,
+    "legend.edgecolor":      validate_color_or_inherit,
+
+    # tick properties
+    "xtick.top":           validate_bool,      # draw ticks on top side
+    "xtick.bottom":        validate_bool,      # draw ticks on bottom side
+    "xtick.labeltop":      validate_bool,      # draw label on top
+    "xtick.labelbottom":   validate_bool,      # draw label on bottom
+    "xtick.major.size":    validate_float,     # major xtick size in points
+    "xtick.minor.size":    validate_float,     # minor xtick size in points
+    "xtick.major.width":   validate_float,     # major xtick width in points
+    "xtick.minor.width":   validate_float,     # minor xtick width in points
+    "xtick.major.pad":     validate_float,     # distance to label in points
+    "xtick.minor.pad":     validate_float,     # distance to label in points
+    "xtick.color":         validate_color,     # color of xticks
+    "xtick.labelcolor":    validate_color_or_inherit,  # color of xtick labels
+    "xtick.minor.visible": validate_bool,      # visibility of minor xticks
+    "xtick.minor.top":     validate_bool,      # draw top minor xticks
+    "xtick.minor.bottom":  validate_bool,      # draw bottom minor xticks
+    "xtick.major.top":     validate_bool,      # draw top major xticks
+    "xtick.major.bottom":  validate_bool,      # draw bottom major xticks
+    # number of minor xticks
+    "xtick.minor.ndivs":   _validate_minor_tick_ndivs,
+    "xtick.labelsize":     validate_fontsize,  # fontsize of xtick labels
+    "xtick.direction":     ["out", "in", "inout"],  # direction of xticks
+    "xtick.alignment":     ["center", "right", "left"],
+
+    "ytick.left":          validate_bool,      # draw ticks on left side
+    "ytick.right":         validate_bool,      # draw ticks on right side
+    "ytick.labelleft":     validate_bool,      # draw tick labels on left side
+    "ytick.labelright":    validate_bool,      # draw tick labels on right side
+    "ytick.major.size":    validate_float,     # major ytick size in points
+    "ytick.minor.size":    validate_float,     # minor ytick size in points
+    "ytick.major.width":   validate_float,     # major ytick width in points
+    "ytick.minor.width":   validate_float,     # minor ytick width in points
+    "ytick.major.pad":     validate_float,     # distance to label in points
+    "ytick.minor.pad":     validate_float,     # distance to label in points
+    "ytick.color":         validate_color,     # color of yticks
+    "ytick.labelcolor":    validate_color_or_inherit,  # color of ytick labels
+    "ytick.minor.visible": validate_bool,      # visibility of minor yticks
+    "ytick.minor.left":    validate_bool,      # draw left minor yticks
+    "ytick.minor.right":   validate_bool,      # draw right minor yticks
+    "ytick.major.left":    validate_bool,      # draw left major yticks
+    "ytick.major.right":   validate_bool,      # draw right major yticks
+    # number of minor yticks
+    "ytick.minor.ndivs":   _validate_minor_tick_ndivs,
+    "ytick.labelsize":     validate_fontsize,  # fontsize of ytick labels
+    "ytick.direction":     ["out", "in", "inout"],  # direction of yticks
+    "ytick.alignment":     [
+        "center", "top", "bottom", "baseline", "center_baseline"],
+
+    "grid.color":        validate_color,  # grid color
+    "grid.linestyle":    _validate_linestyle,  # solid
+    "grid.linewidth":    validate_float,     # in points
+    "grid.alpha":        validate_float,
+
+    ## figure props
+    # figure title
+    "figure.titlesize":   validate_fontsize,
+    "figure.titleweight": validate_fontweight,
+
+    # figure labels
+    "figure.labelsize":   validate_fontsize,
+    "figure.labelweight": validate_fontweight,
+
+    # figure size in inches: width by height
+    "figure.figsize":          _listify_validator(validate_float, n=2),
+    "figure.dpi":              validate_float,
+    "figure.facecolor":        validate_color,
+    "figure.edgecolor":        validate_color,
+    "figure.frameon":          validate_bool,
+    "figure.autolayout":       validate_bool,
+    "figure.max_open_warning": validate_int,
+    "figure.raise_window":     validate_bool,
+    "macosx.window_mode":      ["system", "tab", "window"],
+
+    "figure.subplot.left":   validate_float,
+    "figure.subplot.right":  validate_float,
+    "figure.subplot.bottom": validate_float,
+    "figure.subplot.top":    validate_float,
+    "figure.subplot.wspace": validate_float,
+    "figure.subplot.hspace": validate_float,
+
+    "figure.constrained_layout.use": validate_bool,  # run constrained_layout?
+    # wspace and hspace are fraction of adjacent subplots to use for space.
+    # Much smaller than above because we don't need room for the text.
+    "figure.constrained_layout.hspace": validate_float,
+    "figure.constrained_layout.wspace": validate_float,
+    # buffer around the Axes, in inches.
+    "figure.constrained_layout.h_pad": validate_float,
+    "figure.constrained_layout.w_pad": validate_float,
+
+    ## Saving figure's properties
+    'savefig.dpi':          validate_dpi,
+    'savefig.facecolor':    validate_color_or_auto,
+    'savefig.edgecolor':    validate_color_or_auto,
+    'savefig.orientation':  ['landscape', 'portrait'],
+    "savefig.format":       validate_string,
+    "savefig.bbox":         validate_bbox,  # "tight", or "standard" (= None)
+    "savefig.pad_inches":   validate_float,
+    # default directory in savefig dialog box
+    "savefig.directory":    _validate_pathlike,
+    "savefig.transparent":  validate_bool,
+
+    "tk.window_focus": validate_bool,  # Maintain shell focus for TkAgg
+
+    # Set the papersize/type
+    "ps.papersize":       _validate_papersize,
+    "ps.useafm":          validate_bool,
+    # use ghostscript or xpdf to distill ps output
+    "ps.usedistiller":    validate_ps_distiller,
+    "ps.distiller.res":   validate_int,  # dpi
+    "ps.fonttype":        validate_fonttype,  # 3 (Type3) or 42 (Truetype)
+    "pdf.compression":    validate_int,  # 0-9 compression level; 0 to disable
+    "pdf.inheritcolor":   validate_bool,  # skip color setting commands
+    # use only the 14 PDF core fonts embedded in every PDF viewing application
+    "pdf.use14corefonts": validate_bool,
+    "pdf.fonttype":       validate_fonttype,  # 3 (Type3) or 42 (Truetype)
+
+    "pgf.texsystem": ["xelatex", "lualatex", "pdflatex"],  # latex variant used
+    "pgf.rcfonts":   validate_bool,  # use mpl's rc settings for font config
+    "pgf.preamble":  validate_string,  # custom LaTeX preamble
+
+    # write raster image data into the svg file
+    "svg.image_inline": validate_bool,
+    "svg.fonttype": ["none", "path"],  # save text as text ("none") or "paths"
+    "svg.hashsalt": validate_string_or_None,
+
+    # set this when you want to generate hardcopy docstring
+    "docstring.hardcopy": validate_bool,
+
+    "path.simplify":           validate_bool,
+    "path.simplify_threshold": _validate_greaterequal0_lessequal1,
+    "path.snap":               validate_bool,
+    "path.sketch":             validate_sketch,
+    "path.effects":            validate_anylist,
+    "agg.path.chunksize":      validate_int,  # 0 to disable chunking
+
+    # key-mappings (multi-character mappings should be a list/tuple)
+    "keymap.fullscreen": validate_stringlist,
+    "keymap.home":       validate_stringlist,
+    "keymap.back":       validate_stringlist,
+    "keymap.forward":    validate_stringlist,
+    "keymap.pan":        validate_stringlist,
+    "keymap.zoom":       validate_stringlist,
+    "keymap.save":       validate_stringlist,
+    "keymap.quit":       validate_stringlist,
+    "keymap.quit_all":   validate_stringlist,  # e.g.: "W", "cmd+W", "Q"
+    "keymap.grid":       validate_stringlist,
+    "keymap.grid_minor": validate_stringlist,
+    "keymap.yscale":     validate_stringlist,
+    "keymap.xscale":     validate_stringlist,
+    "keymap.help":       validate_stringlist,
+    "keymap.copy":       validate_stringlist,
+
+    # Animation settings
+    "animation.html":         ["html5", "jshtml", "none"],
+    # Limit, in MB, of size of base64 encoded animation in HTML
+    # (i.e. IPython notebook)
+    "animation.embed_limit":  validate_float,
+    "animation.writer":       validate_string,
+    "animation.codec":        validate_string,
+    "animation.bitrate":      validate_int,
+    # Controls image format when frames are written to disk
+    "animation.frame_format": ["png", "jpeg", "tiff", "raw", "rgba", "ppm",
+                               "sgi", "bmp", "pbm", "svg"],
+    # Path to ffmpeg binary. If just binary name, subprocess uses $PATH.
+    "animation.ffmpeg_path":  _validate_pathlike,
+    # Additional arguments for ffmpeg movie writer (using pipes)
+    "animation.ffmpeg_args":  validate_stringlist,
+     # Path to convert binary. If just binary name, subprocess uses $PATH.
+    "animation.convert_path": _validate_pathlike,
+     # Additional arguments for convert movie writer (using pipes)
+    "animation.convert_args": validate_stringlist,
+
+    # Classic (pre 2.0) compatibility mode
+    # This is used for things that are hard to make backward compatible
+    # with a sane rcParam alone.  This does *not* turn on classic mode
+    # altogether.  For that use `matplotlib.style.use("classic")`.
+    "_internal.classic_mode": validate_bool
+}
+_hardcoded_defaults = {  # Defaults not inferred from
+    # lib/matplotlib/mpl-data/matplotlibrc...
+    # ... because they are private:
+    "_internal.classic_mode": False,
+    # ... because they are deprecated:
+    # No current deprecations.
+    # backend is handled separately when constructing rcParamsDefault.
+}
+_validators = {k: _convert_validator_spec(k, conv)
+               for k, conv in _validators.items()}

llava_next/lib/python3.10/site-packages/matplotlib/sankey.py

@@ -0,0 +1,814 @@
+"""
+Module for creating Sankey diagrams using Matplotlib.
+"""
+
+import logging
+from types import SimpleNamespace
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib.path import Path
+from matplotlib.patches import PathPatch
+from matplotlib.transforms import Affine2D
+from matplotlib import _docstring
+
+_log = logging.getLogger(__name__)
+
+__author__ = "Kevin L. Davies"
+__credits__ = ["Yannick Copin"]
+__license__ = "BSD"
+__version__ = "2011/09/16"
+
+# Angles [deg/90]
+RIGHT = 0
+UP = 1
+# LEFT = 2
+DOWN = 3
+
+
+class Sankey:
+    """
+    Sankey diagram.
+
+      Sankey diagrams are a specific type of flow diagram, in which
+      the width of the arrows is shown proportionally to the flow
+      quantity.  They are typically used to visualize energy or
+      material or cost transfers between processes.
+      `Wikipedia (6/1/2011) <https://en.wikipedia.org/wiki/Sankey_diagram>`_
+
+    """
+
+    def __init__(self, ax=None, scale=1.0, unit='', format='%G', gap=0.25,
+                 radius=0.1, shoulder=0.03, offset=0.15, head_angle=100,
+                 margin=0.4, tolerance=1e-6, **kwargs):
+        """
+        Create a new Sankey instance.
+
+        The optional arguments listed below are applied to all subdiagrams so
+        that there is consistent alignment and formatting.
+
+        In order to draw a complex Sankey diagram, create an instance of
+        `Sankey` by calling it without any kwargs::
+
+            sankey = Sankey()
+
+        Then add simple Sankey sub-diagrams::
+
+            sankey.add() # 1
+            sankey.add() # 2
+            #...
+            sankey.add() # n
+
+        Finally, create the full diagram::
+
+            sankey.finish()
+
+        Or, instead, simply daisy-chain those calls::
+
+            Sankey().add().add...  .add().finish()
+
+        Other Parameters
+        ----------------
+        ax : `~matplotlib.axes.Axes`
+            Axes onto which the data should be plotted.  If *ax* isn't
+            provided, new Axes will be created.
+        scale : float
+            Scaling factor for the flows.  *scale* sizes the width of the paths
+            in order to maintain proper layout.  The same scale is applied to
+            all subdiagrams.  The value should be chosen such that the product
+            of the scale and the sum of the inputs is approximately 1.0 (and
+            the product of the scale and the sum of the outputs is
+            approximately -1.0).
+        unit : str
+            The physical unit associated with the flow quantities.  If *unit*
+            is None, then none of the quantities are labeled.
+        format : str or callable
+            A Python number formatting string or callable used to label the
+            flows with their quantities (i.e., a number times a unit, where the
+            unit is given). If a format string is given, the label will be
+            ``format % quantity``. If a callable is given, it will be called
+            with ``quantity`` as an argument.
+        gap : float
+            Space between paths that break in/break away to/from the top or
+            bottom.
+        radius : float
+            Inner radius of the vertical paths.
+        shoulder : float
+            Size of the shoulders of output arrows.
+        offset : float
+            Text offset (from the dip or tip of the arrow).
+        head_angle : float
+            Angle, in degrees, of the arrow heads (and negative of the angle of
+            the tails).
+        margin : float
+            Minimum space between Sankey outlines and the edge of the plot
+            area.
+        tolerance : float
+            Acceptable maximum of the magnitude of the sum of flows.  The
+            magnitude of the sum of connected flows cannot be greater than
+            *tolerance*.
+        **kwargs
+            Any additional keyword arguments will be passed to `add`, which
+            will create the first subdiagram.
+
+        See Also
+        --------
+        Sankey.add
+        Sankey.finish
+
+        Examples
+        --------
+        .. plot:: gallery/specialty_plots/sankey_basics.py
+        """
+        # Check the arguments.
+        if gap < 0:
+            raise ValueError(
+                "'gap' is negative, which is not allowed because it would "
+                "cause the paths to overlap")
+        if radius > gap:
+            raise ValueError(
+                "'radius' is greater than 'gap', which is not allowed because "
+                "it would cause the paths to overlap")
+        if head_angle < 0:
+            raise ValueError(
+                "'head_angle' is negative, which is not allowed because it "
+                "would cause inputs to look like outputs and vice versa")
+        if tolerance < 0:
+            raise ValueError(
+                "'tolerance' is negative, but it must be a magnitude")
+
+        # Create Axes if necessary.
+        if ax is None:
+            import matplotlib.pyplot as plt
+            fig = plt.figure()
+            ax = fig.add_subplot(1, 1, 1, xticks=[], yticks=[])
+
+        self.diagrams = []
+
+        # Store the inputs.
+        self.ax = ax
+        self.unit = unit
+        self.format = format
+        self.scale = scale
+        self.gap = gap
+        self.radius = radius
+        self.shoulder = shoulder
+        self.offset = offset
+        self.margin = margin
+        self.pitch = np.tan(np.pi * (1 - head_angle / 180.0) / 2.0)
+        self.tolerance = tolerance
+
+        # Initialize the vertices of tight box around the diagram(s).
+        self.extent = np.array((np.inf, -np.inf, np.inf, -np.inf))
+
+        # If there are any kwargs, create the first subdiagram.
+        if len(kwargs):
+            self.add(**kwargs)
+
+    def _arc(self, quadrant=0, cw=True, radius=1, center=(0, 0)):
+        """
+        Return the codes and vertices for a rotated, scaled, and translated
+        90 degree arc.
+
+        Other Parameters
+        ----------------
+        quadrant : {0, 1, 2, 3}, default: 0
+            Uses 0-based indexing (0, 1, 2, or 3).
+        cw : bool, default: True
+            If True, the arc vertices are produced clockwise; counter-clockwise
+            otherwise.
+        radius : float, default: 1
+            The radius of the arc.
+        center : (float, float), default: (0, 0)
+            (x, y) tuple of the arc's center.
+        """
+        # Note:  It would be possible to use matplotlib's transforms to rotate,
+        # scale, and translate the arc, but since the angles are discrete,
+        # it's just as easy and maybe more efficient to do it here.
+        ARC_CODES = [Path.LINETO,
+                     Path.CURVE4,
+                     Path.CURVE4,
+                     Path.CURVE4,
+                     Path.CURVE4,
+                     Path.CURVE4,
+                     Path.CURVE4]
+        # Vertices of a cubic Bezier curve approximating a 90 deg arc
+        # These can be determined by Path.arc(0, 90).
+        ARC_VERTICES = np.array([[1.00000000e+00, 0.00000000e+00],
+                                 [1.00000000e+00, 2.65114773e-01],
+                                 [8.94571235e-01, 5.19642327e-01],
+                                 [7.07106781e-01, 7.07106781e-01],
+                                 [5.19642327e-01, 8.94571235e-01],
+                                 [2.65114773e-01, 1.00000000e+00],
+                                 # Insignificant
+                                 # [6.12303177e-17, 1.00000000e+00]])
+                                 [0.00000000e+00, 1.00000000e+00]])
+        if quadrant in (0, 2):
+            if cw:
+                vertices = ARC_VERTICES
+            else:
+                vertices = ARC_VERTICES[:, ::-1]  # Swap x and y.
+        else:  # 1, 3
+            # Negate x.
+            if cw:
+                # Swap x and y.
+                vertices = np.column_stack((-ARC_VERTICES[:, 1],
+                                             ARC_VERTICES[:, 0]))
+            else:
+                vertices = np.column_stack((-ARC_VERTICES[:, 0],
+                                             ARC_VERTICES[:, 1]))
+        if quadrant > 1:
+            radius = -radius  # Rotate 180 deg.
+        return list(zip(ARC_CODES, radius * vertices +
+                        np.tile(center, (ARC_VERTICES.shape[0], 1))))
+
+    def _add_input(self, path, angle, flow, length):
+        """
+        Add an input to a path and return its tip and label locations.
+        """
+        if angle is None:
+            return [0, 0], [0, 0]
+        else:
+            x, y = path[-1][1]  # Use the last point as a reference.
+            dipdepth = (flow / 2) * self.pitch
+            if angle == RIGHT:
+                x -= length
+                dip = [x + dipdepth, y + flow / 2.0]
+                path.extend([(Path.LINETO, [x, y]),
+                             (Path.LINETO, dip),
+                             (Path.LINETO, [x, y + flow]),
+                             (Path.LINETO, [x + self.gap, y + flow])])
+                label_location = [dip[0] - self.offset, dip[1]]
+            else:  # Vertical
+                x -= self.gap
+                if angle == UP:
+                    sign = 1
+                else:
+                    sign = -1
+
+                dip = [x - flow / 2, y - sign * (length - dipdepth)]
+                if angle == DOWN:
+                    quadrant = 2
+                else:
+                    quadrant = 1
+
+                # Inner arc isn't needed if inner radius is zero
+                if self.radius:
+                    path.extend(self._arc(quadrant=quadrant,
+                                          cw=angle == UP,
+                                          radius=self.radius,
+                                          center=(x + self.radius,
+                                                  y - sign * self.radius)))
+                else:
+                    path.append((Path.LINETO, [x, y]))
+                path.extend([(Path.LINETO, [x, y - sign * length]),
+                             (Path.LINETO, dip),
+                             (Path.LINETO, [x - flow, y - sign * length])])
+                path.extend(self._arc(quadrant=quadrant,
+                                      cw=angle == DOWN,
+                                      radius=flow + self.radius,
+                                      center=(x + self.radius,
+                                              y - sign * self.radius)))
+                path.append((Path.LINETO, [x - flow, y + sign * flow]))
+                label_location = [dip[0], dip[1] - sign * self.offset]
+
+            return dip, label_location
+
+    def _add_output(self, path, angle, flow, length):
+        """
+        Append an output to a path and return its tip and label locations.
+
+        .. note:: *flow* is negative for an output.
+        """
+        if angle is None:
+            return [0, 0], [0, 0]
+        else:
+            x, y = path[-1][1]  # Use the last point as a reference.
+            tipheight = (self.shoulder - flow / 2) * self.pitch
+            if angle == RIGHT:
+                x += length
+                tip = [x + tipheight, y + flow / 2.0]
+                path.extend([(Path.LINETO, [x, y]),
+                             (Path.LINETO, [x, y + self.shoulder]),
+                             (Path.LINETO, tip),
+                             (Path.LINETO, [x, y - self.shoulder + flow]),
+                             (Path.LINETO, [x, y + flow]),
+                             (Path.LINETO, [x - self.gap, y + flow])])
+                label_location = [tip[0] + self.offset, tip[1]]
+            else:  # Vertical
+                x += self.gap
+                if angle == UP:
+                    sign, quadrant = 1, 3
+                else:
+                    sign, quadrant = -1, 0
+
+                tip = [x - flow / 2.0, y + sign * (length + tipheight)]
+                # Inner arc isn't needed if inner radius is zero
+                if self.radius:
+                    path.extend(self._arc(quadrant=quadrant,
+                                          cw=angle == UP,
+                                          radius=self.radius,
+                                          center=(x - self.radius,
+                                                  y + sign * self.radius)))
+                else:
+                    path.append((Path.LINETO, [x, y]))
+                path.extend([(Path.LINETO, [x, y + sign * length]),
+                             (Path.LINETO, [x - self.shoulder,
+                                            y + sign * length]),
+                             (Path.LINETO, tip),
+                             (Path.LINETO, [x + self.shoulder - flow,
+                                            y + sign * length]),
+                             (Path.LINETO, [x - flow, y + sign * length])])
+                path.extend(self._arc(quadrant=quadrant,
+                                      cw=angle == DOWN,
+                                      radius=self.radius - flow,
+                                      center=(x - self.radius,
+                                              y + sign * self.radius)))
+                path.append((Path.LINETO, [x - flow, y + sign * flow]))
+                label_location = [tip[0], tip[1] + sign * self.offset]
+            return tip, label_location
+
+    def _revert(self, path, first_action=Path.LINETO):
+        """
+        A path is not simply reversible by path[::-1] since the code
+        specifies an action to take from the **previous** point.
+        """
+        reverse_path = []
+        next_code = first_action
+        for code, position in path[::-1]:
+            reverse_path.append((next_code, position))
+            next_code = code
+        return reverse_path
+        # This might be more efficient, but it fails because 'tuple' object
+        # doesn't support item assignment:
+        # path[1] = path[1][-1:0:-1]
+        # path[1][0] = first_action
+        # path[2] = path[2][::-1]
+        # return path
+
+    @_docstring.dedent_interpd
+    def add(self, patchlabel='', flows=None, orientations=None, labels='',
+            trunklength=1.0, pathlengths=0.25, prior=None, connect=(0, 0),
+            rotation=0, **kwargs):
+        """
+        Add a simple Sankey diagram with flows at the same hierarchical level.
+
+        Parameters
+        ----------
+        patchlabel : str
+            Label to be placed at the center of the diagram.
+            Note that *label* (not *patchlabel*) can be passed as keyword
+            argument to create an entry in the legend.
+
+        flows : list of float
+            Array of flow values.  By convention, inputs are positive and
+            outputs are negative.
+
+            Flows are placed along the top of the diagram from the inside out
+            in order of their index within *flows*.  They are placed along the
+            sides of the diagram from the top down and along the bottom from
+            the outside in.
+
+            If the sum of the inputs and outputs is
+            nonzero, the discrepancy will appear as a cubic B��zier curve along
+            the top and bottom edges of the trunk.
+
+        orientations : list of {-1, 0, 1}
+            List of orientations of the flows (or a single orientation to be
+            used for all flows).  Valid values are 0 (inputs from
+            the left, outputs to the right), 1 (from and to the top) or -1
+            (from and to the bottom).
+
+        labels : list of (str or None)
+            List of labels for the flows (or a single label to be used for all
+            flows).  Each label may be *None* (no label), or a labeling string.
+            If an entry is a (possibly empty) string, then the quantity for the
+            corresponding flow will be shown below the string.  However, if
+            the *unit* of the main diagram is None, then quantities are never
+            shown, regardless of the value of this argument.
+
+        trunklength : float
+            Length between the bases of the input and output groups (in
+            data-space units).
+
+        pathlengths : list of float
+            List of lengths of the vertical arrows before break-in or after
+            break-away.  If a single value is given, then it will be applied to
+            the first (inside) paths on the top and bottom, and the length of
+            all other arrows will be justified accordingly.  The *pathlengths*
+            are not applied to the horizontal inputs and outputs.
+
+        prior : int
+            Index of the prior diagram to which this diagram should be
+            connected.
+
+        connect : (int, int)
+            A (prior, this) tuple indexing the flow of the prior diagram and
+            the flow of this diagram which should be connected.  If this is the
+            first diagram or *prior* is *None*, *connect* will be ignored.
+
+        rotation : float
+            Angle of rotation of the diagram in degrees.  The interpretation of
+            the *orientations* argument will be rotated accordingly (e.g., if
+            *rotation* == 90, an *orientations* entry of 1 means to/from the
+            left).  *rotation* is ignored if this diagram is connected to an
+            existing one (using *prior* and *connect*).
+
+        Returns
+        -------
+        Sankey
+            The current `.Sankey` instance.
+
+        Other Parameters
+        ----------------
+        **kwargs
+           Additional keyword arguments set `matplotlib.patches.PathPatch`
+           properties, listed below.  For example, one may want to use
+           ``fill=False`` or ``label="A legend entry"``.
+
+        %(Patch:kwdoc)s
+
+        See Also
+        --------
+        Sankey.finish
+        """
+        # Check and preprocess the arguments.
+        flows = np.array([1.0, -1.0]) if flows is None else np.array(flows)
+        n = flows.shape[0]  # Number of flows
+        if rotation is None:
+            rotation = 0
+        else:
+            # In the code below, angles are expressed in deg/90.
+            rotation /= 90.0
+        if orientations is None:
+            orientations = 0
+        try:
+            orientations = np.broadcast_to(orientations, n)
+        except ValueError:
+            raise ValueError(
+                f"The shapes of 'flows' {np.shape(flows)} and 'orientations' "
+                f"{np.shape(orientations)} are incompatible"
+            ) from None
+        try:
+            labels = np.broadcast_to(labels, n)
+        except ValueError:
+            raise ValueError(
+                f"The shapes of 'flows' {np.shape(flows)} and 'labels' "
+                f"{np.shape(labels)} are incompatible"
+            ) from None
+        if trunklength < 0:
+            raise ValueError(
+                "'trunklength' is negative, which is not allowed because it "
+                "would cause poor layout")
+        if abs(np.sum(flows)) > self.tolerance:
+            _log.info("The sum of the flows is nonzero (%f; patchlabel=%r); "
+                      "is the system not at steady state?",
+                      np.sum(flows), patchlabel)
+        scaled_flows = self.scale * flows
+        gain = sum(max(flow, 0) for flow in scaled_flows)
+        loss = sum(min(flow, 0) for flow in scaled_flows)
+        if prior is not None:
+            if prior < 0:
+                raise ValueError("The index of the prior diagram is negative")
+            if min(connect) < 0:
+                raise ValueError(
+                    "At least one of the connection indices is negative")
+            if prior >= len(self.diagrams):
+                raise ValueError(
+                    f"The index of the prior diagram is {prior}, but there "
+                    f"are only {len(self.diagrams)} other diagrams")
+            if connect[0] >= len(self.diagrams[prior].flows):
+                raise ValueError(
+                    "The connection index to the source diagram is {}, but "
+                    "that diagram has only {} flows".format(
+                        connect[0], len(self.diagrams[prior].flows)))
+            if connect[1] >= n:
+                raise ValueError(
+                    f"The connection index to this diagram is {connect[1]}, "
+                    f"but this diagram has only {n} flows")
+            if self.diagrams[prior].angles[connect[0]] is None:
+                raise ValueError(
+                    f"The connection cannot be made, which may occur if the "
+                    f"magnitude of flow {connect[0]} of diagram {prior} is "
+                    f"less than the specified tolerance")
+            flow_error = (self.diagrams[prior].flows[connect[0]] +
+                          flows[connect[1]])
+            if abs(flow_error) >= self.tolerance:
+                raise ValueError(
+                    f"The scaled sum of the connected flows is {flow_error}, "
+                    f"which is not within the tolerance ({self.tolerance})")
+
+        # Determine if the flows are inputs.
+        are_inputs = [None] * n
+        for i, flow in enumerate(flows):
+            if flow >= self.tolerance:
+                are_inputs[i] = True
+            elif flow <= -self.tolerance:
+                are_inputs[i] = False
+            else:
+                _log.info(
+                    "The magnitude of flow %d (%f) is below the tolerance "
+                    "(%f).\nIt will not be shown, and it cannot be used in a "
+                    "connection.", i, flow, self.tolerance)
+
+        # Determine the angles of the arrows (before rotation).
+        angles = [None] * n
+        for i, (orient, is_input) in enumerate(zip(orientations, are_inputs)):
+            if orient == 1:
+                if is_input:
+                    angles[i] = DOWN
+                elif is_input is False:
+                    # Be specific since is_input can be None.
+                    angles[i] = UP
+            elif orient == 0:
+                if is_input is not None:
+                    angles[i] = RIGHT
+            else:
+                if orient != -1:
+                    raise ValueError(
+                        f"The value of orientations[{i}] is {orient}, "
+                        f"but it must be -1, 0, or 1")
+                if is_input:
+                    angles[i] = UP
+                elif is_input is False:
+                    angles[i] = DOWN
+
+        # Justify the lengths of the paths.
+        if np.iterable(pathlengths):
+            if len(pathlengths) != n:
+                raise ValueError(
+                    f"The lengths of 'flows' ({n}) and 'pathlengths' "
+                    f"({len(pathlengths)}) are incompatible")
+        else:  # Make pathlengths into a list.
+            urlength = pathlengths
+            ullength = pathlengths
+            lrlength = pathlengths
+            lllength = pathlengths
+            d = dict(RIGHT=pathlengths)
+            pathlengths = [d.get(angle, 0) for angle in angles]
+            # Determine the lengths of the top-side arrows
+            # from the middle outwards.
+            for i, (angle, is_input, flow) in enumerate(zip(angles, are_inputs,
+                                                            scaled_flows)):
+                if angle == DOWN and is_input:
+                    pathlengths[i] = ullength
+                    ullength += flow
+                elif angle == UP and is_input is False:
+                    pathlengths[i] = urlength
+                    urlength -= flow  # Flow is negative for outputs.
+            # Determine the lengths of the bottom-side arrows
+            # from the middle outwards.
+            for i, (angle, is_input, flow) in enumerate(reversed(list(zip(
+                  angles, are_inputs, scaled_flows)))):
+                if angle == UP and is_input:
+                    pathlengths[n - i - 1] = lllength
+                    lllength += flow
+                elif angle == DOWN and is_input is False:
+                    pathlengths[n - i - 1] = lrlength
+                    lrlength -= flow
+            # Determine the lengths of the left-side arrows
+            # from the bottom upwards.
+            has_left_input = False
+            for i, (angle, is_input, spec) in enumerate(reversed(list(zip(
+                  angles, are_inputs, zip(scaled_flows, pathlengths))))):
+                if angle == RIGHT:
+                    if is_input:
+                        if has_left_input:
+                            pathlengths[n - i - 1] = 0
+                        else:
+                            has_left_input = True
+            # Determine the lengths of the right-side arrows
+            # from the top downwards.
+            has_right_output = False
+            for i, (angle, is_input, spec) in enumerate(zip(
+                  angles, are_inputs, list(zip(scaled_flows, pathlengths)))):
+                if angle == RIGHT:
+                    if is_input is False:
+                        if has_right_output:
+                            pathlengths[i] = 0
+                        else:
+                            has_right_output = True
+
+        # Begin the subpaths, and smooth the transition if the sum of the flows
+        # is nonzero.
+        urpath = [(Path.MOVETO, [(self.gap - trunklength / 2.0),  # Upper right
+                                 gain / 2.0]),
+                  (Path.LINETO, [(self.gap - trunklength / 2.0) / 2.0,
+                                 gain / 2.0]),
+                  (Path.CURVE4, [(self.gap - trunklength / 2.0) / 8.0,
+                                 gain / 2.0]),
+                  (Path.CURVE4, [(trunklength / 2.0 - self.gap) / 8.0,
+                                 -loss / 2.0]),
+                  (Path.LINETO, [(trunklength / 2.0 - self.gap) / 2.0,
+                                 -loss / 2.0]),
+                  (Path.LINETO, [(trunklength / 2.0 - self.gap),
+                                 -loss / 2.0])]
+        llpath = [(Path.LINETO, [(trunklength / 2.0 - self.gap),  # Lower left
+                                 loss / 2.0]),
+                  (Path.LINETO, [(trunklength / 2.0 - self.gap) / 2.0,
+                                 loss / 2.0]),
+                  (Path.CURVE4, [(trunklength / 2.0 - self.gap) / 8.0,
+                                 loss / 2.0]),
+                  (Path.CURVE4, [(self.gap - trunklength / 2.0) / 8.0,
+                                 -gain / 2.0]),
+                  (Path.LINETO, [(self.gap - trunklength / 2.0) / 2.0,
+                                 -gain / 2.0]),
+                  (Path.LINETO, [(self.gap - trunklength / 2.0),
+                                 -gain / 2.0])]
+        lrpath = [(Path.LINETO, [(trunklength / 2.0 - self.gap),  # Lower right
+                                 loss / 2.0])]
+        ulpath = [(Path.LINETO, [self.gap - trunklength / 2.0,  # Upper left
+                                 gain / 2.0])]
+
+        # Add the subpaths and assign the locations of the tips and labels.
+        tips = np.zeros((n, 2))
+        label_locations = np.zeros((n, 2))
+        # Add the top-side inputs and outputs from the middle outwards.
+        for i, (angle, is_input, spec) in enumerate(zip(
+              angles, are_inputs, list(zip(scaled_flows, pathlengths)))):
+            if angle == DOWN and is_input:
+                tips[i, :], label_locations[i, :] = self._add_input(
+                    ulpath, angle, *spec)
+            elif angle == UP and is_input is False:
+                tips[i, :], label_locations[i, :] = self._add_output(
+                    urpath, angle, *spec)
+        # Add the bottom-side inputs and outputs from the middle outwards.
+        for i, (angle, is_input, spec) in enumerate(reversed(list(zip(
+              angles, are_inputs, list(zip(scaled_flows, pathlengths)))))):
+            if angle == UP and is_input:
+                tip, label_location = self._add_input(llpath, angle, *spec)
+                tips[n - i - 1, :] = tip
+                label_locations[n - i - 1, :] = label_location
+            elif angle == DOWN and is_input is False:
+                tip, label_location = self._add_output(lrpath, angle, *spec)
+                tips[n - i - 1, :] = tip
+                label_locations[n - i - 1, :] = label_location
+        # Add the left-side inputs from the bottom upwards.
+        has_left_input = False
+        for i, (angle, is_input, spec) in enumerate(reversed(list(zip(
+              angles, are_inputs, list(zip(scaled_flows, pathlengths)))))):
+            if angle == RIGHT and is_input:
+                if not has_left_input:
+                    # Make sure the lower path extends
+                    # at least as far as the upper one.
+                    if llpath[-1][1][0] > ulpath[-1][1][0]:
+                        llpath.append((Path.LINETO, [ulpath[-1][1][0],
+                                                     llpath[-1][1][1]]))
+                    has_left_input = True
+                tip, label_location = self._add_input(llpath, angle, *spec)
+                tips[n - i - 1, :] = tip
+                label_locations[n - i - 1, :] = label_location
+        # Add the right-side outputs from the top downwards.
+        has_right_output = False
+        for i, (angle, is_input, spec) in enumerate(zip(
+              angles, are_inputs, list(zip(scaled_flows, pathlengths)))):
+            if angle == RIGHT and is_input is False:
+                if not has_right_output:
+                    # Make sure the upper path extends
+                    # at least as far as the lower one.
+                    if urpath[-1][1][0] < lrpath[-1][1][0]:
+                        urpath.append((Path.LINETO, [lrpath[-1][1][0],
+                                                     urpath[-1][1][1]]))
+                    has_right_output = True
+                tips[i, :], label_locations[i, :] = self._add_output(
+                    urpath, angle, *spec)
+        # Trim any hanging vertices.
+        if not has_left_input:
+            ulpath.pop()
+            llpath.pop()
+        if not has_right_output:
+            lrpath.pop()
+            urpath.pop()
+
+        # Concatenate the subpaths in the correct order (clockwise from top).
+        path = (urpath + self._revert(lrpath) + llpath + self._revert(ulpath) +
+                [(Path.CLOSEPOLY, urpath[0][1])])
+
+        # Create a patch with the Sankey outline.
+        codes, vertices = zip(*path)
+        vertices = np.array(vertices)
+
+        def _get_angle(a, r):
+            if a is None:
+                return None
+            else:
+                return a + r
+
+        if prior is None:
+            if rotation != 0:  # By default, none of this is needed.
+                angles = [_get_angle(angle, rotation) for angle in angles]
+                rotate = Affine2D().rotate_deg(rotation * 90).transform_affine
+                tips = rotate(tips)
+                label_locations = rotate(label_locations)
+                vertices = rotate(vertices)
+            text = self.ax.text(0, 0, s=patchlabel, ha='center', va='center')
+        else:
+            rotation = (self.diagrams[prior].angles[connect[0]] -
+                        angles[connect[1]])
+            angles = [_get_angle(angle, rotation) for angle in angles]
+            rotate = Affine2D().rotate_deg(rotation * 90).transform_affine
+            tips = rotate(tips)
+            offset = self.diagrams[prior].tips[connect[0]] - tips[connect[1]]
+            translate = Affine2D().translate(*offset).transform_affine
+            tips = translate(tips)
+            label_locations = translate(rotate(label_locations))
+            vertices = translate(rotate(vertices))
+            kwds = dict(s=patchlabel, ha='center', va='center')
+            text = self.ax.text(*offset, **kwds)
+        if mpl.rcParams['_internal.classic_mode']:
+            fc = kwargs.pop('fc', kwargs.pop('facecolor', '#bfd1d4'))
+            lw = kwargs.pop('lw', kwargs.pop('linewidth', 0.5))
+        else:
+            fc = kwargs.pop('fc', kwargs.pop('facecolor', None))
+            lw = kwargs.pop('lw', kwargs.pop('linewidth', None))
+        if fc is None:
+            fc = self.ax._get_patches_for_fill.get_next_color()
+        patch = PathPatch(Path(vertices, codes), fc=fc, lw=lw, **kwargs)
+        self.ax.add_patch(patch)
+
+        # Add the path labels.
+        texts = []
+        for number, angle, label, location in zip(flows, angles, labels,
+                                                  label_locations):
+            if label is None or angle is None:
+                label = ''
+            elif self.unit is not None:
+                if isinstance(self.format, str):
+                    quantity = self.format % abs(number) + self.unit
+                elif callable(self.format):
+                    quantity = self.format(number)
+                else:
+                    raise TypeError(
+                        'format must be callable or a format string')
+                if label != '':
+                    label += "\n"
+                label += quantity
+            texts.append(self.ax.text(x=location[0], y=location[1],
+                                      s=label,
+                                      ha='center', va='center'))
+        # Text objects are placed even they are empty (as long as the magnitude
+        # of the corresponding flow is larger than the tolerance) in case the
+        # user wants to provide labels later.
+
+        # Expand the size of the diagram if necessary.
+        self.extent = (min(np.min(vertices[:, 0]),
+                           np.min(label_locations[:, 0]),
+                           self.extent[0]),
+                       max(np.max(vertices[:, 0]),
+                           np.max(label_locations[:, 0]),
+                           self.extent[1]),
+                       min(np.min(vertices[:, 1]),
+                           np.min(label_locations[:, 1]),
+                           self.extent[2]),
+                       max(np.max(vertices[:, 1]),
+                           np.max(label_locations[:, 1]),
+                           self.extent[3]))
+        # Include both vertices _and_ label locations in the extents; there are
+        # where either could determine the margins (e.g., arrow shoulders).
+
+        # Add this diagram as a subdiagram.
+        self.diagrams.append(
+            SimpleNamespace(patch=patch, flows=flows, angles=angles, tips=tips,
+                            text=text, texts=texts))
+
+        # Allow a daisy-chained call structure (see docstring for the class).
+        return self
+
+    def finish(self):
+        """
+        Adjust the Axes and return a list of information about the Sankey
+        subdiagram(s).
+
+        Returns a list of subdiagrams with the following fields:
+
+        ========  =============================================================
+        Field     Description
+        ========  =============================================================
+        *patch*   Sankey outline (a `~matplotlib.patches.PathPatch`).
+        *flows*   Flow values (positive for input, negative for output).
+        *angles*  List of angles of the arrows [deg/90].
+                  For example, if the diagram has not been rotated,
+                  an input to the top side has an angle of 3 (DOWN),
+                  and an output from the top side has an angle of 1 (UP).
+                  If a flow has been skipped (because its magnitude is less
+                  than *tolerance*), then its angle will be *None*.
+        *tips*    (N, 2)-array of the (x, y) positions of the tips (or "dips")
+                  of the flow paths.
+                  If the magnitude of a flow is less the *tolerance* of this
+                  `Sankey` instance, the flow is skipped and its tip will be at
+                  the center of the diagram.
+        *text*    `.Text` instance for the diagram label.
+        *texts*   List of `.Text` instances for the flow labels.
+        ========  =============================================================
+
+        See Also
+        --------
+        Sankey.add
+        """
+        self.ax.axis([self.extent[0] - self.margin,
+                      self.extent[1] + self.margin,
+                      self.extent[2] - self.margin,
+                      self.extent[3] + self.margin])
+        self.ax.set_aspect('equal', adjustable='datalim')
+        return self.diagrams

llava_next/lib/python3.10/site-packages/matplotlib/sankey.pyi

@@ -0,0 +1,61 @@
+from matplotlib.axes import Axes
+
+from collections.abc import Callable, Iterable
+from typing import Any
+
+import numpy as np
+
+__license__: str
+__credits__: list[str]
+__author__: str
+__version__: str
+
+RIGHT: int
+UP: int
+DOWN: int
+
+# TODO typing units
+class Sankey:
+    diagrams: list[Any]
+    ax: Axes
+    unit: Any
+    format: str | Callable[[float], str]
+    scale: float
+    gap: float
+    radius: float
+    shoulder: float
+    offset: float
+    margin: float
+    pitch: float
+    tolerance: float
+    extent: np.ndarray
+    def __init__(
+        self,
+        ax: Axes | None = ...,
+        scale: float = ...,
+        unit: Any = ...,
+        format: str | Callable[[float], str] = ...,
+        gap: float = ...,
+        radius: float = ...,
+        shoulder: float = ...,
+        offset: float = ...,
+        head_angle: float = ...,
+        margin: float = ...,
+        tolerance: float = ...,
+        **kwargs
+    ) -> None: ...
+    def add(
+        self,
+        patchlabel: str = ...,
+        flows: Iterable[float] | None = ...,
+        orientations: Iterable[int] | None = ...,
+        labels: str | Iterable[str | None] = ...,
+        trunklength: float = ...,
+        pathlengths: float | Iterable[float] = ...,
+        prior: int | None = ...,
+        connect: tuple[int, int] = ...,
+        rotation: float = ...,
+        **kwargs
+        # Replace return with Self when py3.9 is dropped
+    ) -> Sankey: ...
+    def finish(self) -> list[Any]: ...

llava_next/lib/python3.10/site-packages/matplotlib/streamplot.pyi

@@ -0,0 +1,82 @@
+from matplotlib.axes import Axes
+from matplotlib.colors import Normalize, Colormap
+from matplotlib.collections import LineCollection, PatchCollection
+from matplotlib.patches import ArrowStyle
+from matplotlib.transforms import Transform
+
+from typing import Literal
+from numpy.typing import ArrayLike
+from .typing import ColorType
+
+def streamplot(
+    axes: Axes,
+    x: ArrayLike,
+    y: ArrayLike,
+    u: ArrayLike,
+    v: ArrayLike,
+    density: float | tuple[float, float] = ...,
+    linewidth: float | ArrayLike | None = ...,
+    color: ColorType | ArrayLike | None = ...,
+    cmap: str | Colormap | None = ...,
+    norm: str | Normalize | None = ...,
+    arrowsize: float = ...,
+    arrowstyle: str | ArrowStyle = ...,
+    minlength: float = ...,
+    transform: Transform | None = ...,
+    zorder: float | None = ...,
+    start_points: ArrayLike | None = ...,
+    maxlength: float = ...,
+    integration_direction: Literal["forward", "backward", "both"] = ...,
+    broken_streamlines: bool = ...,
+) -> StreamplotSet: ...
+
+class StreamplotSet:
+    lines: LineCollection
+    arrows: PatchCollection
+    def __init__(self, lines: LineCollection, arrows: PatchCollection) -> None: ...
+
+class DomainMap:
+    grid: Grid
+    mask: StreamMask
+    x_grid2mask: float
+    y_grid2mask: float
+    x_mask2grid: float
+    y_mask2grid: float
+    x_data2grid: float
+    y_data2grid: float
+    def __init__(self, grid: Grid, mask: StreamMask) -> None: ...
+    def grid2mask(self, xi: float, yi: float) -> tuple[int, int]: ...
+    def mask2grid(self, xm: float, ym: float) -> tuple[float, float]: ...
+    def data2grid(self, xd: float, yd: float) -> tuple[float, float]: ...
+    def grid2data(self, xg: float, yg: float) -> tuple[float, float]: ...
+    def start_trajectory(
+        self, xg: float, yg: float, broken_streamlines: bool = ...
+    ) -> None: ...
+    def reset_start_point(self, xg: float, yg: float) -> None: ...
+    def update_trajectory(self, xg, yg, broken_streamlines: bool = ...) -> None: ...
+    def undo_trajectory(self) -> None: ...
+
+class Grid:
+    nx: int
+    ny: int
+    dx: float
+    dy: float
+    x_origin: float
+    y_origin: float
+    width: float
+    height: float
+    def __init__(self, x: ArrayLike, y: ArrayLike) -> None: ...
+    @property
+    def shape(self) -> tuple[int, int]: ...
+    def within_grid(self, xi: float, yi: float) -> bool: ...
+
+class StreamMask:
+    nx: int
+    ny: int
+    shape: tuple[int, int]
+    def __init__(self, density: float | tuple[float, float]) -> None: ...
+    def __getitem__(self, args): ...
+
+class InvalidIndexError(Exception): ...
+class TerminateTrajectory(Exception): ...
+class OutOfBounds(IndexError): ...

llava_next/lib/python3.10/site-packages/matplotlib/style/__init__.py

@@ -0,0 +1,4 @@
+from .core import available, context, library, reload_library, use
+
+
+__all__ = ["available", "context", "library", "reload_library", "use"]

llava_next/lib/python3.10/site-packages/matplotlib/style/core.py

@@ -0,0 +1,245 @@
+"""
+Core functions and attributes for the matplotlib style library:
+
+``use``
+    Select style sheet to override the current matplotlib settings.
+``context``
+    Context manager to use a style sheet temporarily.
+``available``
+    List available style sheets.
+``library``
+    A dictionary of style names and matplotlib settings.
+"""
+
+import contextlib
+import logging
+import os
+from pathlib import Path
+import sys
+import warnings
+
+if sys.version_info >= (3, 10):
+    import importlib.resources as importlib_resources
+else:
+    # Even though Py3.9 has importlib.resources, it doesn't properly handle
+    # modules added in sys.path.
+    import importlib_resources
+
+import matplotlib as mpl
+from matplotlib import _api, _docstring, _rc_params_in_file, rcParamsDefault
+
+_log = logging.getLogger(__name__)
+
+__all__ = ['use', 'context', 'available', 'library', 'reload_library']
+
+
+BASE_LIBRARY_PATH = os.path.join(mpl.get_data_path(), 'stylelib')
+# Users may want multiple library paths, so store a list of paths.
+USER_LIBRARY_PATHS = [os.path.join(mpl.get_configdir(), 'stylelib')]
+STYLE_EXTENSION = 'mplstyle'
+# A list of rcParams that should not be applied from styles
+STYLE_BLACKLIST = {
+    'interactive', 'backend', 'webagg.port', 'webagg.address',
+    'webagg.port_retries', 'webagg.open_in_browser', 'backend_fallback',
+    'toolbar', 'timezone', 'figure.max_open_warning',
+    'figure.raise_window', 'savefig.directory', 'tk.window_focus',
+    'docstring.hardcopy', 'date.epoch'}
+
+
+@_docstring.Substitution(
+    "\n".join(map("- {}".format, sorted(STYLE_BLACKLIST, key=str.lower)))
+)
+def use(style):
+    """
+    Use Matplotlib style settings from a style specification.
+
+    The style name of 'default' is reserved for reverting back to
+    the default style settings.
+
+    .. note::
+
+       This updates the `.rcParams` with the settings from the style.
+       `.rcParams` not defined in the style are kept.
+
+    Parameters
+    ----------
+    style : str, dict, Path or list
+
+        A style specification. Valid options are:
+
+        str
+            - One of the style names in `.style.available` (a builtin style or
+              a style installed in the user library path).
+
+            - A dotted name of the form "package.style_name"; in that case,
+              "package" should be an importable Python package name, e.g. at
+              ``/path/to/package/__init__.py``; the loaded style file is
+              ``/path/to/package/style_name.mplstyle``.  (Style files in
+              subpackages are likewise supported.)
+
+            - The path or URL to a style file, which gets loaded by
+              `.rc_params_from_file`.
+
+        dict
+            A mapping of key/value pairs for `matplotlib.rcParams`.
+
+        Path
+            The path to a style file, which gets loaded by
+            `.rc_params_from_file`.
+
+        list
+            A list of style specifiers (str, Path or dict), which are applied
+            from first to last in the list.
+
+    Notes
+    -----
+    The following `.rcParams` are not related to style and will be ignored if
+    found in a style specification:
+
+    %s
+    """
+    if isinstance(style, (str, Path)) or hasattr(style, 'keys'):
+        # If name is a single str, Path or dict, make it a single element list.
+        styles = [style]
+    else:
+        styles = style
+
+    style_alias = {'mpl20': 'default', 'mpl15': 'classic'}
+
+    for style in styles:
+        if isinstance(style, str):
+            style = style_alias.get(style, style)
+            if style == "default":
+                # Deprecation warnings were already handled when creating
+                # rcParamsDefault, no need to reemit them here.
+                with _api.suppress_matplotlib_deprecation_warning():
+                    # don't trigger RcParams.__getitem__('backend')
+                    style = {k: rcParamsDefault[k] for k in rcParamsDefault
+                             if k not in STYLE_BLACKLIST}
+            elif style in library:
+                style = library[style]
+            elif "." in style:
+                pkg, _, name = style.rpartition(".")
+                try:
+                    path = (importlib_resources.files(pkg)
+                            / f"{name}.{STYLE_EXTENSION}")
+                    style = _rc_params_in_file(path)
+                except (ModuleNotFoundError, OSError, TypeError) as exc:
+                    # There is an ambiguity whether a dotted name refers to a
+                    # package.style_name or to a dotted file path.  Currently,
+                    # we silently try the first form and then the second one;
+                    # in the future, we may consider forcing file paths to
+                    # either use Path objects or be prepended with "./" and use
+                    # the slash as marker for file paths.
+                    pass
+        if isinstance(style, (str, Path)):
+            try:
+                style = _rc_params_in_file(style)
+            except OSError as err:
+                raise OSError(
+                    f"{style!r} is not a valid package style, path of style "
+                    f"file, URL of style file, or library style name (library "
+                    f"styles are listed in `style.available`)") from err
+        filtered = {}
+        for k in style:  # don't trigger RcParams.__getitem__('backend')
+            if k in STYLE_BLACKLIST:
+                _api.warn_external(
+                    f"Style includes a parameter, {k!r}, that is not "
+                    f"related to style.  Ignoring this parameter.")
+            else:
+                filtered[k] = style[k]
+        mpl.rcParams.update(filtered)
+
+
+@contextlib.contextmanager
+def context(style, after_reset=False):
+    """
+    Context manager for using style settings temporarily.
+
+    Parameters
+    ----------
+    style : str, dict, Path or list
+        A style specification. Valid options are:
+
+        str
+            - One of the style names in `.style.available` (a builtin style or
+              a style installed in the user library path).
+
+            - A dotted name of the form "package.style_name"; in that case,
+              "package" should be an importable Python package name, e.g. at
+              ``/path/to/package/__init__.py``; the loaded style file is
+              ``/path/to/package/style_name.mplstyle``.  (Style files in
+              subpackages are likewise supported.)
+
+            - The path or URL to a style file, which gets loaded by
+              `.rc_params_from_file`.
+        dict
+            A mapping of key/value pairs for `matplotlib.rcParams`.
+
+        Path
+            The path to a style file, which gets loaded by
+            `.rc_params_from_file`.
+
+        list
+            A list of style specifiers (str, Path or dict), which are applied
+            from first to last in the list.
+
+    after_reset : bool
+        If True, apply style after resetting settings to their defaults;
+        otherwise, apply style on top of the current settings.
+    """
+    with mpl.rc_context():
+        if after_reset:
+            mpl.rcdefaults()
+        use(style)
+        yield
+
+
+def update_user_library(library):
+    """Update style library with user-defined rc files."""
+    for stylelib_path in map(os.path.expanduser, USER_LIBRARY_PATHS):
+        styles = read_style_directory(stylelib_path)
+        update_nested_dict(library, styles)
+    return library
+
+
+def read_style_directory(style_dir):
+    """Return dictionary of styles defined in *style_dir*."""
+    styles = dict()
+    for path in Path(style_dir).glob(f"*.{STYLE_EXTENSION}"):
+        with warnings.catch_warnings(record=True) as warns:
+            styles[path.stem] = _rc_params_in_file(path)
+        for w in warns:
+            _log.warning('In %s: %s', path, w.message)
+    return styles
+
+
+def update_nested_dict(main_dict, new_dict):
+    """
+    Update nested dict (only level of nesting) with new values.
+
+    Unlike `dict.update`, this assumes that the values of the parent dict are
+    dicts (or dict-like), so you shouldn't replace the nested dict if it
+    already exists. Instead you should update the sub-dict.
+    """
+    # update named styles specified by user
+    for name, rc_dict in new_dict.items():
+        main_dict.setdefault(name, {}).update(rc_dict)
+    return main_dict
+
+
+# Load style library
+# ==================
+_base_library = read_style_directory(BASE_LIBRARY_PATH)
+library = {}
+available = []
+
+
+def reload_library():
+    """Reload the style library."""
+    library.clear()
+    library.update(update_user_library(_base_library))
+    available[:] = sorted(library.keys())
+
+
+reload_library()

llava_next/lib/python3.10/site-packages/matplotlib/style/core.pyi

@@ -0,0 +1,19 @@
+from collections.abc import Generator
+import contextlib
+
+from matplotlib import RcParams
+from matplotlib.typing import RcStyleType
+
+USER_LIBRARY_PATHS: list[str] = ...
+STYLE_EXTENSION: str = ...
+
+def use(style: RcStyleType) -> None: ...
+@contextlib.contextmanager
+def context(
+    style: RcStyleType, after_reset: bool = ...
+) -> Generator[None, None, None]: ...
+
+library: dict[str, RcParams]
+available: list[str]
+
+def reload_library() -> None: ...

llava_next/lib/python3.10/site-packages/matplotlib/testing/__init__.py

@@ -0,0 +1,234 @@
+"""
+Helper functions for testing.
+"""
+from pathlib import Path
+from tempfile import TemporaryDirectory
+import locale
+import logging
+import os
+import subprocess
+import sys
+
+import matplotlib as mpl
+from matplotlib import _api
+
+_log = logging.getLogger(__name__)
+
+
+def set_font_settings_for_testing():
+    mpl.rcParams['font.family'] = 'DejaVu Sans'
+    mpl.rcParams['text.hinting'] = 'none'
+    mpl.rcParams['text.hinting_factor'] = 8
+
+
+def set_reproducibility_for_testing():
+    mpl.rcParams['svg.hashsalt'] = 'matplotlib'
+
+
+def setup():
+    # The baseline images are created in this locale, so we should use
+    # it during all of the tests.
+
+    try:
+        locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
+    except locale.Error:
+        try:
+            locale.setlocale(locale.LC_ALL, 'English_United States.1252')
+        except locale.Error:
+            _log.warning(
+                "Could not set locale to English/United States. "
+                "Some date-related tests may fail.")
+
+    mpl.use('Agg')
+
+    with _api.suppress_matplotlib_deprecation_warning():
+        mpl.rcdefaults()  # Start with all defaults
+
+    # These settings *must* be hardcoded for running the comparison tests and
+    # are not necessarily the default values as specified in rcsetup.py.
+    set_font_settings_for_testing()
+    set_reproducibility_for_testing()
+
+
+def subprocess_run_for_testing(command, env=None, timeout=60, stdout=None,
+                               stderr=None, check=False, text=True,
+                               capture_output=False):
+    """
+    Create and run a subprocess.
+
+    Thin wrapper around `subprocess.run`, intended for testing.  Will
+    mark fork() failures on Cygwin as expected failures: not a
+    success, but not indicating a problem with the code either.
+
+    Parameters
+    ----------
+    args : list of str
+    env : dict[str, str]
+    timeout : float
+    stdout, stderr
+    check : bool
+    text : bool
+        Also called ``universal_newlines`` in subprocess.  I chose this
+        name since the main effect is returning bytes (`False`) vs. str
+        (`True`), though it also tries to normalize newlines across
+        platforms.
+    capture_output : bool
+        Set stdout and stderr to subprocess.PIPE
+
+    Returns
+    -------
+    proc : subprocess.Popen
+
+    See Also
+    --------
+    subprocess.run
+
+    Raises
+    ------
+    pytest.xfail
+        If platform is Cygwin and subprocess reports a fork() failure.
+    """
+    if capture_output:
+        stdout = stderr = subprocess.PIPE
+    try:
+        proc = subprocess.run(
+            command, env=env,
+            timeout=timeout, check=check,
+            stdout=stdout, stderr=stderr,
+            text=text
+        )
+    except BlockingIOError:
+        if sys.platform == "cygwin":
+            # Might want to make this more specific
+            import pytest
+            pytest.xfail("Fork failure")
+        raise
+    return proc
+
+
+def subprocess_run_helper(func, *args, timeout, extra_env=None):
+    """
+    Run a function in a sub-process.
+
+    Parameters
+    ----------
+    func : function
+        The function to be run.  It must be in a module that is importable.
+    *args : str
+        Any additional command line arguments to be passed in
+        the first argument to ``subprocess.run``.
+    extra_env : dict[str, str]
+        Any additional environment variables to be set for the subprocess.
+    """
+    target = func.__name__
+    module = func.__module__
+    file = func.__code__.co_filename
+    proc = subprocess_run_for_testing(
+        [
+            sys.executable,
+            "-c",
+            f"import importlib.util;"
+            f"_spec = importlib.util.spec_from_file_location({module!r}, {file!r});"
+            f"_module = importlib.util.module_from_spec(_spec);"
+            f"_spec.loader.exec_module(_module);"
+            f"_module.{target}()",
+            *args
+        ],
+        env={**os.environ, "SOURCE_DATE_EPOCH": "0", **(extra_env or {})},
+        timeout=timeout, check=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True
+    )
+    return proc
+
+
+def _check_for_pgf(texsystem):
+    """
+    Check if a given TeX system + pgf is available
+
+    Parameters
+    ----------
+    texsystem : str
+        The executable name to check
+    """
+    with TemporaryDirectory() as tmpdir:
+        tex_path = Path(tmpdir, "test.tex")
+        tex_path.write_text(r"""
+            \documentclass{article}
+            \usepackage{pgf}
+            \begin{document}
+            \typeout{pgfversion=\pgfversion}
+            \makeatletter
+            \@@end
+        """, encoding="utf-8")
+        try:
+            subprocess.check_call(
+                [texsystem, "-halt-on-error", str(tex_path)], cwd=tmpdir,
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        except (OSError, subprocess.CalledProcessError):
+            return False
+        return True
+
+
+def _has_tex_package(package):
+    try:
+        mpl.dviread.find_tex_file(f"{package}.sty")
+        return True
+    except FileNotFoundError:
+        return False
+
+
+def ipython_in_subprocess(requested_backend_or_gui_framework, all_expected_backends):
+    import pytest
+    IPython = pytest.importorskip("IPython")
+
+    if sys.platform == "win32":
+        pytest.skip("Cannot change backend running IPython in subprocess on Windows")
+
+    if (IPython.version_info[:3] == (8, 24, 0) and
+            requested_backend_or_gui_framework == "osx"):
+        pytest.skip("Bug using macosx backend in IPython 8.24.0 fixed in 8.24.1")
+
+    # This code can be removed when Python 3.12, the latest version supported
+    # by IPython < 8.24, reaches end-of-life in late 2028.
+    for min_version, backend in all_expected_backends.items():
+        if IPython.version_info[:2] >= min_version:
+            expected_backend = backend
+            break
+
+    code = ("import matplotlib as mpl, matplotlib.pyplot as plt;"
+            "fig, ax=plt.subplots(); ax.plot([1, 3, 2]); mpl.get_backend()")
+    proc = subprocess_run_for_testing(
+        [
+            "ipython",
+            "--no-simple-prompt",
+            f"--matplotlib={requested_backend_or_gui_framework}",
+            "-c", code,
+        ],
+        check=True,
+        capture_output=True,
+    )
+
+    assert proc.stdout.strip().endswith(f"'{expected_backend}'")
+
+
+def is_ci_environment():
+    # Common CI variables
+    ci_environment_variables = [
+        'CI',        # Generic CI environment variable
+        'CONTINUOUS_INTEGRATION',  # Generic CI environment variable
+        'TRAVIS',    # Travis CI
+        'CIRCLECI',  # CircleCI
+        'JENKINS',   # Jenkins
+        'GITLAB_CI',  # GitLab CI
+        'GITHUB_ACTIONS',  # GitHub Actions
+        'TEAMCITY_VERSION'  # TeamCity
+        # Add other CI environment variables as needed
+    ]
+
+    for env_var in ci_environment_variables:
+        if os.getenv(env_var):
+            return True
+
+    return False

llava_next/lib/python3.10/site-packages/matplotlib/testing/__init__.pyi

@@ -0,0 +1,54 @@
+from collections.abc import Callable
+import subprocess
+from typing import Any, IO, Literal, overload
+
+def set_font_settings_for_testing() -> None: ...
+def set_reproducibility_for_testing() -> None: ...
+def setup() -> None: ...
+@overload
+def subprocess_run_for_testing(
+    command: list[str],
+    env: dict[str, str] | None = ...,
+    timeout: float | None = ...,
+    stdout: int | IO[Any] | None = ...,
+    stderr: int | IO[Any] | None = ...,
+    check: bool = ...,
+    *,
+    text: Literal[True],
+    capture_output: bool = ...,
+) -> subprocess.CompletedProcess[str]: ...
+@overload
+def subprocess_run_for_testing(
+    command: list[str],
+    env: dict[str, str] | None = ...,
+    timeout: float | None = ...,
+    stdout: int | IO[Any] | None = ...,
+    stderr: int | IO[Any] | None = ...,
+    check: bool = ...,
+    text: Literal[False] = ...,
+    capture_output: bool = ...,
+) -> subprocess.CompletedProcess[bytes]: ...
+@overload
+def subprocess_run_for_testing(
+    command: list[str],
+    env: dict[str, str] | None = ...,
+    timeout: float | None = ...,
+    stdout: int | IO[Any] | None = ...,
+    stderr: int | IO[Any] | None = ...,
+    check: bool = ...,
+    text: bool = ...,
+    capture_output: bool = ...,
+) -> subprocess.CompletedProcess[bytes] | subprocess.CompletedProcess[str]: ...
+def subprocess_run_helper(
+    func: Callable[[], None],
+    *args: Any,
+    timeout: float,
+    extra_env: dict[str, str] | None = ...,
+) -> subprocess.CompletedProcess[str]: ...
+def _check_for_pgf(texsystem: str) -> bool: ...
+def _has_tex_package(package: str) -> bool: ...
+def ipython_in_subprocess(
+    requested_backend_or_gui_framework: str,
+    all_expected_backends: dict[tuple[int, int], str],
+) -> None: ...
+def is_ci_environment() -> bool: ...

llava_next/lib/python3.10/site-packages/matplotlib/testing/_markers.py

@@ -0,0 +1,49 @@
+"""
+pytest markers for the internal Matplotlib test suite.
+"""
+
+import logging
+import shutil
+
+import pytest
+
+import matplotlib.testing
+import matplotlib.testing.compare
+from matplotlib import _get_executable_info, ExecutableNotFoundError
+
+
+_log = logging.getLogger(__name__)
+
+
+def _checkdep_usetex() -> bool:
+    if not shutil.which("tex"):
+        _log.warning("usetex mode requires TeX.")
+        return False
+    try:
+        _get_executable_info("dvipng")
+    except ExecutableNotFoundError:
+        _log.warning("usetex mode requires dvipng.")
+        return False
+    try:
+        _get_executable_info("gs")
+    except ExecutableNotFoundError:
+        _log.warning("usetex mode requires ghostscript.")
+        return False
+    return True
+
+
+needs_ghostscript = pytest.mark.skipif(
+    "eps" not in matplotlib.testing.compare.converter,
+    reason="This test needs a ghostscript installation")
+needs_pgf_lualatex = pytest.mark.skipif(
+    not matplotlib.testing._check_for_pgf('lualatex'),
+    reason='lualatex + pgf is required')
+needs_pgf_pdflatex = pytest.mark.skipif(
+    not matplotlib.testing._check_for_pgf('pdflatex'),
+    reason='pdflatex + pgf is required')
+needs_pgf_xelatex = pytest.mark.skipif(
+    not matplotlib.testing._check_for_pgf('xelatex'),
+    reason='xelatex + pgf is required')
+needs_usetex = pytest.mark.skipif(
+    not _checkdep_usetex(),
+    reason="This test needs a TeX installation")