Add files using upload-large-folder tool

infer_4_37_2/lib/python3.10/site-packages/contourpy-1.3.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

infer_4_37_2/lib/python3.10/site-packages/contourpy-1.3.1.dist-info/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2021-2024, ContourPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

infer_4_37_2/lib/python3.10/site-packages/contourpy-1.3.1.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.1
+Name: contourpy
+Version: 1.3.1
+Summary: Python library for calculating contours of 2D quadrilateral grids
+Author-Email: Ian Thomas <ianthomas23@gmail.com>
+License: BSD 3-Clause License
+         
+         Copyright (c) 2021-2024, ContourPy Developers.
+         All rights reserved.
+         
+         Redistribution and use in source and binary forms, with or without
+         modification, are permitted provided that the following conditions are met:
+         
+         1. Redistributions of source code must retain the above copyright notice, this
+            list of conditions and the following disclaimer.
+         
+         2. Redistributions in binary form must reproduce the above copyright notice,
+            this list of conditions and the following disclaimer in the documentation
+            and/or other materials provided with the distribution.
+         
+         3. Neither the name of the copyright holder nor the names of its
+            contributors may be used to endorse or promote products derived from
+            this software without specific prior written permission.
+         
+         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+         AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+         IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+         DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+         FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+         DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+         SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+         CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+         OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+         OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+         
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Project-URL: Homepage, https://github.com/contourpy/contourpy
+Project-URL: Changelog, https://contourpy.readthedocs.io/en/latest/changelog.html
+Project-URL: Documentation, https://contourpy.readthedocs.io
+Project-URL: Repository, https://github.com/contourpy/contourpy
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.23
+Provides-Extra: docs
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: sphinx>=7.2; extra == "docs"
+Requires-Dist: sphinx-copybutton; extra == "docs"
+Provides-Extra: bokeh
+Requires-Dist: bokeh; extra == "bokeh"
+Requires-Dist: selenium; extra == "bokeh"
+Provides-Extra: mypy
+Requires-Dist: contourpy[bokeh,docs]; extra == "mypy"
+Requires-Dist: docutils-stubs; extra == "mypy"
+Requires-Dist: mypy==1.11.1; extra == "mypy"
+Requires-Dist: types-Pillow; extra == "mypy"
+Provides-Extra: test
+Requires-Dist: contourpy[test-no-images]; extra == "test"
+Requires-Dist: matplotlib; extra == "test"
+Requires-Dist: Pillow; extra == "test"
+Provides-Extra: test-no-images
+Requires-Dist: pytest; extra == "test-no-images"
+Requires-Dist: pytest-cov; extra == "test-no-images"
+Requires-Dist: pytest-rerunfailures; extra == "test-no-images"
+Requires-Dist: pytest-xdist; extra == "test-no-images"
+Requires-Dist: wurlitzer; extra == "test-no-images"
+Description-Content-Type: text/markdown
+
+<img alt="ContourPy" src="https://raw.githubusercontent.com/contourpy/contourpy/main/docs/_static/contourpy_logo_horiz.svg" height="90">
+
+ContourPy is a Python library for calculating contours of 2D quadrilateral grids.  It is written in C++11 and wrapped using pybind11.
+
+It contains the 2005 and 2014 algorithms used in Matplotlib as well as a newer algorithm that includes more features and is available in both serial and multithreaded versions.  It provides an easy way for Python libraries to use contouring algorithms without having to include Matplotlib as a dependency.
+
+  * **Documentation**: https://contourpy.readthedocs.io
+  * **Source code**: https://github.com/contourpy/contourpy
+
+| | |
+| --- | --- |
+| Latest release | [![PyPI version](https://img.shields.io/pypi/v/contourpy.svg?label=pypi&color=fdae61)](https://pypi.python.org/pypi/contourpy) [![conda-forge version](https://img.shields.io/conda/v/conda-forge/contourpy.svg?label=conda-forge&color=a6d96a)](https://anaconda.org/conda-forge/contourpy) |
+| Downloads | [![PyPi downloads](https://img.shields.io/pypi/dm/contourpy?label=pypi&style=flat&color=fdae61)](https://pepy.tech/project/contourpy) |
+| Python version | [![Platforms](https://img.shields.io/pypi/pyversions/contourpy?color=fdae61)](https://pypi.org/project/contourpy/) |
+| Coverage | [![Codecov](https://img.shields.io/codecov/c/gh/contourpy/contourpy?color=fdae61&label=codecov)](https://app.codecov.io/gh/contourpy/contourpy) |

infer_4_37_2/lib/python3.10/site-packages/contourpy-1.3.1.dist-info/RECORD

@@ -0,0 +1,43 @@
+contourpy-1.3.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+contourpy-1.3.1.dist-info/LICENSE,sha256=x9ChU7_6oQQERGPrxjN5PUUXIu_TE4tf_SUntA8VBaI,1534
+contourpy-1.3.1.dist-info/METADATA,sha256=LQNae4q9MVNwpfb0FlnTCTe2tkw22GiKEJjpks9n7jk,5423
+contourpy-1.3.1.dist-info/RECORD,,
+contourpy-1.3.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+contourpy-1.3.1.dist-info/WHEEL,sha256=sZM_NeUMz2G4fDenMf11eikcCxcLaQWiYRmjwQBavQs,137
+contourpy/__init__.py,sha256=Vi2YbtUhM9VxYPY3PBvxfu0xZYr6fBysl5gQPJEo88k,11831
+contourpy/__pycache__/__init__.cpython-310.pyc,,
+contourpy/__pycache__/_version.cpython-310.pyc,,
+contourpy/__pycache__/array.cpython-310.pyc,,
+contourpy/__pycache__/chunk.cpython-310.pyc,,
+contourpy/__pycache__/convert.cpython-310.pyc,,
+contourpy/__pycache__/dechunk.cpython-310.pyc,,
+contourpy/__pycache__/enum_util.cpython-310.pyc,,
+contourpy/__pycache__/typecheck.cpython-310.pyc,,
+contourpy/__pycache__/types.cpython-310.pyc,,
+contourpy/_contourpy.cpython-310-x86_64-linux-gnu.so,sha256=H8GWcYv0tePHkvGU0HhmBO_d_Chj3Bs_6QYgLRKjIMI,854312
+contourpy/_contourpy.pyi,sha256=fvtccxkiZwGb6qYag7Fp4E8bsFmAIjAmobf8LNxqfgc,7122
+contourpy/_version.py,sha256=-ypEJktJToAL9by62JJKWEzDo_KPCQtmE5kwFgX24z4,22
+contourpy/array.py,sha256=4WwLuiZe30rizn_raymmY13OzE6hlCsDOO8kuVFOP18,8979
+contourpy/chunk.py,sha256=8njDQqlpuD22RjaaCyA75FXQsSQDY5hZGJSrxFpvGGU,3279
+contourpy/convert.py,sha256=mhyn7prEoWCnf0igaH-VqDwlk-CegFsZ4qOy2LL-hpU,26154
+contourpy/dechunk.py,sha256=EgFL6hw5H54ccuof4tJ2ehdnktT7trgZjiZqppsH8QI,7756
+contourpy/enum_util.py,sha256=o8MItJRs08oqzwPP3IwC75BBAY9Qq95saIzjkXBXwqA,1519
+contourpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+contourpy/typecheck.py,sha256=t1nvvCuKMYva1Zx4fc30EpdKFcO0Enz3n_UFfXBsq9o,10747
+contourpy/types.py,sha256=2K4T5tJpMIjYrkkg1Lqh3C2ZKlnOhnMtYmtwz92l_y8,247
+contourpy/util/__init__.py,sha256=eVhJ_crOHL7nkG4Kb0dOo7NL4WHMy_Px665aAN_3d-8,118
+contourpy/util/__pycache__/__init__.cpython-310.pyc,,
+contourpy/util/__pycache__/_build_config.cpython-310.pyc,,
+contourpy/util/__pycache__/bokeh_renderer.cpython-310.pyc,,
+contourpy/util/__pycache__/bokeh_util.cpython-310.pyc,,
+contourpy/util/__pycache__/data.cpython-310.pyc,,
+contourpy/util/__pycache__/mpl_renderer.cpython-310.pyc,,
+contourpy/util/__pycache__/mpl_util.cpython-310.pyc,,
+contourpy/util/__pycache__/renderer.cpython-310.pyc,,
+contourpy/util/_build_config.py,sha256=jzJKkuBQpyjnX1U_eltbhIAN_i6fbzTAQXMAP1YTlG0,1848
+contourpy/util/bokeh_renderer.py,sha256=wNGBghEVA4x11wrSerb3dBbdRxX6E8kuoqlaKPoHTQ8,13769
+contourpy/util/bokeh_util.py,sha256=wc-S3ewBUYWyIkEv9jkhFySIergjLQl4Z0UEVnE0HhA,2804
+contourpy/util/data.py,sha256=-7SSGMLX_gN-1H2JzpNSEB_EcEF_uMtYdOo_ePRIcg8,2586
+contourpy/util/mpl_renderer.py,sha256=avUxO7_MQRDQM84X5PZ9GbNtGxG0EXPSVQYV00xQMvQ,20089
+contourpy/util/mpl_util.py,sha256=0Jz5f-aA9XMWlpO2pDnHbkVgxIiw4SY_ysxf_gACWEo,3452
+contourpy/util/renderer.py,sha256=8CBHzPmVsFPfqsWxqrxGBhqFpJhVeFHFeDzVXAgT8Fc,5118

infer_4_37_2/lib/python3.10/site-packages/contourpy-1.3.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+

infer_4_37_2/lib/python3.10/site-packages/matplotlib/__init__.py

@@ -0,0 +1,1576 @@
+"""
+An object-oriented plotting library.
+
+A procedural interface is provided by the companion pyplot module,
+which may be imported directly, e.g.::
+
+    import matplotlib.pyplot as plt
+
+or using ipython::
+
+    ipython
+
+at your terminal, followed by::
+
+    In [1]: %matplotlib
+    In [2]: import matplotlib.pyplot as plt
+
+at the ipython shell prompt.
+
+For the most part, direct use of the explicit object-oriented library is
+encouraged when programming; the implicit pyplot interface is primarily for
+working interactively. The exceptions to this suggestion are the pyplot
+functions `.pyplot.figure`, `.pyplot.subplot`, `.pyplot.subplots`, and
+`.pyplot.savefig`, which can greatly simplify scripting.  See
+:ref:`api_interfaces` for an explanation of the tradeoffs between the implicit
+and explicit interfaces.
+
+Modules include:
+
+:mod:`matplotlib.axes`
+    The `~.axes.Axes` class.  Most pyplot functions are wrappers for
+    `~.axes.Axes` methods.  The axes module is the highest level of OO
+    access to the library.
+
+:mod:`matplotlib.figure`
+    The `.Figure` class.
+
+:mod:`matplotlib.artist`
+    The `.Artist` base class for all classes that draw things.
+
+:mod:`matplotlib.lines`
+    The `.Line2D` class for drawing lines and markers.
+
+:mod:`matplotlib.patches`
+    Classes for drawing polygons.
+
+:mod:`matplotlib.text`
+    The `.Text` and `.Annotation` classes.
+
+:mod:`matplotlib.image`
+    The `.AxesImage` and `.FigureImage` classes.
+
+:mod:`matplotlib.collections`
+    Classes for efficient drawing of groups of lines or polygons.
+
+:mod:`matplotlib.colors`
+    Color specifications and making colormaps.
+
+:mod:`matplotlib.cm`
+    Colormaps, and the `.ScalarMappable` mixin class for providing color
+    mapping functionality to other classes.
+
+:mod:`matplotlib.ticker`
+    Calculation of tick mark locations and formatting of tick labels.
+
+:mod:`matplotlib.backends`
+    A subpackage with modules for various GUI libraries and output formats.
+
+The base matplotlib namespace includes:
+
+`~matplotlib.rcParams`
+    Default configuration settings; their defaults may be overridden using
+    a :file:`matplotlibrc` file.
+
+`~matplotlib.use`
+    Setting the Matplotlib backend.  This should be called before any
+    figure is created, because it is not possible to switch between
+    different GUI backends after that.
+
+The following environment variables can be used to customize the behavior:
+
+:envvar:`MPLBACKEND`
+    This optional variable can be set to choose the Matplotlib backend. See
+    :ref:`what-is-a-backend`.
+
+:envvar:`MPLCONFIGDIR`
+    This is the directory used to store user customizations to
+    Matplotlib, as well as some caches to improve performance. If
+    :envvar:`MPLCONFIGDIR` is not defined, :file:`{HOME}/.config/matplotlib`
+    and :file:`{HOME}/.cache/matplotlib` are used on Linux, and
+    :file:`{HOME}/.matplotlib` on other platforms, if they are
+    writable. Otherwise, the Python standard library's `tempfile.gettempdir`
+    is used to find a base directory in which the :file:`matplotlib`
+    subdirectory is created.
+
+Matplotlib was initially written by John D. Hunter (1968-2012) and is now
+developed and maintained by a host of others.
+
+Occasionally the internal documentation (python docstrings) will refer
+to MATLAB®, a registered trademark of The MathWorks, Inc.
+
+"""
+
+__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",
+    "multivar_colormaps",
+    "bivar_colormaps",
+    "color_sequences",
+]
+
+
+import atexit
+from collections import namedtuple
+from collections.abc import MutableMapping
+import contextlib
+import functools
+import importlib
+import inspect
+from inspect import Parameter
+import locale
+import logging
+import os
+from pathlib import Path
+import pprint
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+
+from packaging.version import parse as parse_version
+
+# cbook must import matplotlib only within function
+# definitions, so it is safe to import from it here.
+from . import _api, _version, cbook, _docstring, rcsetup
+from matplotlib._api import MatplotlibDeprecationWarning
+from matplotlib.rcsetup import cycler  # noqa: F401
+
+
+_log = logging.getLogger(__name__)
+
+__bibtex__ = r"""@Article{Hunter:2007,
+  Author    = {Hunter, J. D.},
+  Title     = {Matplotlib: A 2D graphics environment},
+  Journal   = {Computing in Science \& Engineering},
+  Volume    = {9},
+  Number    = {3},
+  Pages     = {90--95},
+  abstract  = {Matplotlib is a 2D graphics package used for Python
+  for application development, interactive scripting, and
+  publication-quality image generation across user
+  interfaces and operating systems.},
+  publisher = {IEEE COMPUTER SOC},
+  year      = 2007
+}"""
+
+# modelled after sys.version_info
+_VersionInfo = namedtuple('_VersionInfo',
+                          'major, minor, micro, releaselevel, serial')
+
+
+def _parse_to_version_info(version_str):
+    """
+    Parse a version string to a namedtuple analogous to sys.version_info.
+
+    See:
+    https://packaging.pypa.io/en/latest/version.html#packaging.version.parse
+    https://docs.python.org/3/library/sys.html#sys.version_info
+    """
+    v = parse_version(version_str)
+    if v.pre is None and v.post is None and v.dev is None:
+        return _VersionInfo(v.major, v.minor, v.micro, 'final', 0)
+    elif v.dev is not None:
+        return _VersionInfo(v.major, v.minor, v.micro, 'alpha', v.dev)
+    elif v.pre is not None:
+        releaselevel = {
+            'a': 'alpha',
+            'b': 'beta',
+            'rc': 'candidate'}.get(v.pre[0], 'alpha')
+        return _VersionInfo(v.major, v.minor, v.micro, releaselevel, v.pre[1])
+    else:
+        # fallback for v.post: guess-next-dev scheme from setuptools_scm
+        return _VersionInfo(v.major, v.minor, v.micro + 1, 'alpha', v.post)
+
+
+def _get_version():
+    """Return the version string used for __version__."""
+    # Only shell out to a git subprocess if really needed, i.e. when we are in
+    # a matplotlib git repo but not in a shallow clone, such as those used by
+    # CI, as the latter would trigger a warning from setuptools_scm.
+    root = Path(__file__).resolve().parents[2]
+    if ((root / ".matplotlib-repo").exists()
+            and (root / ".git").exists()
+            and not (root / ".git/shallow").exists()):
+        try:
+            import setuptools_scm
+        except ImportError:
+            pass
+        else:
+            return setuptools_scm.get_version(
+                root=root,
+                dist_name="matplotlib",
+                version_scheme="release-branch-semver",
+                local_scheme="node-and-date",
+                fallback_version=_version.version,
+            )
+    # Get the version from the _version.py file if not in repo or setuptools_scm is
+    # unavailable.
+    return _version.version
+
+
+@_api.caching_module_getattr
+class __getattr__:
+    __version__ = property(lambda self: _get_version())
+    __version_info__ = property(
+        lambda self: _parse_to_version_info(self.__version__))
+
+
+def _check_versions():
+
+    # Quickfix to ensure Microsoft Visual C++ redistributable
+    # DLLs are loaded before importing kiwisolver
+    from . import ft2font  # noqa: F401
+
+    for modname, minver in [
+            ("cycler", "0.10"),
+            ("dateutil", "2.7"),
+            ("kiwisolver", "1.3.1"),
+            ("numpy", "1.23"),
+            ("pyparsing", "2.3.1"),
+    ]:
+        module = importlib.import_module(modname)
+        if parse_version(module.__version__) < parse_version(minver):
+            raise ImportError(f"Matplotlib requires {modname}>={minver}; "
+                              f"you have {module.__version__}")
+
+
+_check_versions()
+
+
+# The decorator ensures this always returns the same handler (and it is only
+# attached once).
+@functools.cache
+def _ensure_handler():
+    """
+    The first time this function is called, attach a `StreamHandler` using the
+    same format as `logging.basicConfig` to the Matplotlib root logger.
+
+    Return this handler every time this function is called.
+    """
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(logging.BASIC_FORMAT))
+    _log.addHandler(handler)
+    return handler
+
+
+def set_loglevel(level):
+    """
+    Configure Matplotlib's logging levels.
+
+    Matplotlib uses the standard library `logging` framework under the root
+    logger 'matplotlib'.  This is a helper function to:
+
+    - set Matplotlib's root logger level
+    - set the root logger handler's level, creating the handler
+      if it does not exist yet
+
+    Typically, one should call ``set_loglevel("info")`` or
+    ``set_loglevel("debug")`` to get additional debugging information.
+
+    Users or applications that are installing their own logging handlers
+    may want to directly manipulate ``logging.getLogger('matplotlib')`` rather
+    than use this function.
+
+    Parameters
+    ----------
+    level : {"notset", "debug", "info", "warning", "error", "critical"}
+        The log level of the handler.
+
+    Notes
+    -----
+    The first time this function is called, an additional handler is attached
+    to Matplotlib's root handler; this handler is reused every time and this
+    function simply manipulates the logger and handler's level.
+
+    """
+    _log.setLevel(level.upper())
+    _ensure_handler().setLevel(level.upper())
+
+
+def _logged_cached(fmt, func=None):
+    """
+    Decorator that logs a function's return value, and memoizes that value.
+
+    After ::
+
+        @_logged_cached(fmt)
+        def func(): ...
+
+    the first call to *func* will log its return value at the DEBUG level using
+    %-format string *fmt*, and memoize it; later calls to *func* will directly
+    return that value.
+    """
+    if func is None:  # Return the actual decorator.
+        return functools.partial(_logged_cached, fmt)
+
+    called = False
+    ret = None
+
+    @functools.wraps(func)
+    def wrapper(**kwargs):
+        nonlocal called, ret
+        if not called:
+            ret = func(**kwargs)
+            called = True
+            _log.debug(fmt, ret)
+        return ret
+
+    return wrapper
+
+
+_ExecInfo = namedtuple("_ExecInfo", "executable raw_version version")
+
+
+class ExecutableNotFoundError(FileNotFoundError):
+    """
+    Error raised when an executable that Matplotlib optionally
+    depends on can't be found.
+    """
+    pass
+
+
+@functools.cache
+def _get_executable_info(name):
+    """
+    Get the version of some executable that Matplotlib optionally depends on.
+
+    .. warning::
+       The list of executables that this function supports is set according to
+       Matplotlib's internal needs, and may change without notice.
+
+    Parameters
+    ----------
+    name : str
+        The executable to query.  The following values are currently supported:
+        "dvipng", "gs", "inkscape", "magick", "pdftocairo", "pdftops".  This
+        list is subject to change without notice.
+
+    Returns
+    -------
+    tuple
+        A namedtuple with fields ``executable`` (`str`) and ``version``
+        (`packaging.Version`, or ``None`` if the version cannot be determined).
+
+    Raises
+    ------
+    ExecutableNotFoundError
+        If the executable is not found or older than the oldest version
+        supported by Matplotlib.  For debugging purposes, it is also
+        possible to "hide" an executable from Matplotlib by adding it to the
+        :envvar:`_MPLHIDEEXECUTABLES` environment variable (a comma-separated
+        list), which must be set prior to any calls to this function.
+    ValueError
+        If the executable is not one that we know how to query.
+    """
+
+    def impl(args, regex, min_ver=None, ignore_exit_code=False):
+        # Execute the subprocess specified by args; capture stdout and stderr.
+        # Search for a regex match in the output; if the match succeeds, the
+        # first group of the match is the version.
+        # Return an _ExecInfo if the executable exists, and has a version of
+        # at least min_ver (if set); else, raise ExecutableNotFoundError.
+        try:
+            output = subprocess.check_output(
+                args, stderr=subprocess.STDOUT,
+                text=True, errors="replace")
+        except subprocess.CalledProcessError as _cpe:
+            if ignore_exit_code:
+                output = _cpe.output
+            else:
+                raise ExecutableNotFoundError(str(_cpe)) from _cpe
+        except OSError as _ose:
+            raise ExecutableNotFoundError(str(_ose)) from _ose
+        match = re.search(regex, output)
+        if match:
+            raw_version = match.group(1)
+            version = parse_version(raw_version)
+            if min_ver is not None and version < parse_version(min_ver):
+                raise ExecutableNotFoundError(
+                    f"You have {args[0]} version {version} but the minimum "
+                    f"version supported by Matplotlib is {min_ver}")
+            return _ExecInfo(args[0], raw_version, version)
+        else:
+            raise ExecutableNotFoundError(
+                f"Failed to determine the version of {args[0]} from "
+                f"{' '.join(args)}, which output {output}")
+
+    if name in os.environ.get("_MPLHIDEEXECUTABLES", "").split(","):
+        raise ExecutableNotFoundError(f"{name} was hidden")
+
+    if name == "dvipng":
+        return impl(["dvipng", "-version"], "(?m)^dvipng(?: .*)? (.+)", "1.6")
+    elif name == "gs":
+        execs = (["gswin32c", "gswin64c", "mgs", "gs"]  # "mgs" for miktex.
+                 if sys.platform == "win32" else
+                 ["gs"])
+        for e in execs:
+            try:
+                return impl([e, "--version"], "(.*)", "9")
+            except ExecutableNotFoundError:
+                pass
+        message = "Failed to find a Ghostscript installation"
+        raise ExecutableNotFoundError(message)
+    elif name == "inkscape":
+        try:
+            # Try headless option first (needed for Inkscape version < 1.0):
+            return impl(["inkscape", "--without-gui", "-V"],
+                        "Inkscape ([^ ]*)")
+        except ExecutableNotFoundError:
+            pass  # Suppress exception chaining.
+        # If --without-gui is not accepted, we may be using Inkscape >= 1.0 so
+        # try without it:
+        return impl(["inkscape", "-V"], "Inkscape ([^ ]*)")
+    elif name == "magick":
+        if sys.platform == "win32":
+            # Check the registry to avoid confusing ImageMagick's convert with
+            # Windows's builtin convert.exe.
+            import winreg
+            binpath = ""
+            for flag in [0, winreg.KEY_WOW64_32KEY, winreg.KEY_WOW64_64KEY]:
+                try:
+                    with winreg.OpenKeyEx(
+                            winreg.HKEY_LOCAL_MACHINE,
+                            r"Software\Imagemagick\Current",
+                            0, winreg.KEY_QUERY_VALUE | flag) as hkey:
+                        binpath = winreg.QueryValueEx(hkey, "BinPath")[0]
+                except OSError:
+                    pass
+            path = None
+            if binpath:
+                for name in ["convert.exe", "magick.exe"]:
+                    candidate = Path(binpath, name)
+                    if candidate.exists():
+                        path = str(candidate)
+                        break
+            if path is None:
+                raise ExecutableNotFoundError(
+                    "Failed to find an ImageMagick installation")
+        else:
+            path = "convert"
+        info = impl([path, "--version"], r"^Version: ImageMagick (\S*)")
+        if info.raw_version == "7.0.10-34":
+            # https://github.com/ImageMagick/ImageMagick/issues/2720
+            raise ExecutableNotFoundError(
+                f"You have ImageMagick {info.version}, which is unsupported")
+        return info
+    elif name == "pdftocairo":
+        return impl(["pdftocairo", "-v"], "pdftocairo version (.*)")
+    elif name == "pdftops":
+        info = impl(["pdftops", "-v"], "^pdftops version (.*)",
+                    ignore_exit_code=True)
+        if info and not (
+                3 <= info.version.major or
+                # poppler version numbers.
+                parse_version("0.9") <= info.version < parse_version("1.0")):
+            raise ExecutableNotFoundError(
+                f"You have pdftops version {info.version} but the minimum "
+                f"version supported by Matplotlib is 3.0")
+        return info
+    else:
+        raise ValueError(f"Unknown executable: {name!r}")
+
+
+def _get_xdg_config_dir():
+    """
+    Return the XDG configuration directory, according to the XDG base
+    directory spec:
+
+    https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+    """
+    return os.environ.get('XDG_CONFIG_HOME') or str(Path.home() / ".config")
+
+
+def _get_xdg_cache_dir():
+    """
+    Return the XDG cache directory, according to the XDG base directory spec:
+
+    https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+    """
+    return os.environ.get('XDG_CACHE_HOME') or str(Path.home() / ".cache")
+
+
+def _get_config_or_cache_dir(xdg_base_getter):
+    configdir = os.environ.get('MPLCONFIGDIR')
+    if configdir:
+        configdir = Path(configdir)
+    elif sys.platform.startswith(('linux', 'freebsd')):
+        # Only call _xdg_base_getter here so that MPLCONFIGDIR is tried first,
+        # as _xdg_base_getter can throw.
+        configdir = Path(xdg_base_getter(), "matplotlib")
+    else:
+        configdir = Path.home() / ".matplotlib"
+    # Resolve the path to handle potential issues with inaccessible symlinks.
+    configdir = configdir.resolve()
+    try:
+        configdir.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:
+        _log.warning("mkdir -p failed for path %s: %s", configdir, exc)
+    else:
+        if os.access(str(configdir), os.W_OK) and configdir.is_dir():
+            return str(configdir)
+        _log.warning("%s is not a writable directory", configdir)
+    # If the config or cache directory cannot be created or is not a writable
+    # directory, create a temporary one.
+    try:
+        tmpdir = tempfile.mkdtemp(prefix="matplotlib-")
+    except OSError as exc:
+        raise OSError(
+            f"Matplotlib requires access to a writable cache directory, but there "
+            f"was an issue with the default path ({configdir}), and a temporary "
+            f"directory could not be created; set the MPLCONFIGDIR environment "
+            f"variable to a writable directory") from exc
+    os.environ["MPLCONFIGDIR"] = tmpdir
+    atexit.register(shutil.rmtree, tmpdir)
+    _log.warning(
+        "Matplotlib created a temporary cache directory at %s because there was "
+        "an issue with the default path (%s); it is highly recommended to set the "
+        "MPLCONFIGDIR environment variable to a writable directory, in particular to "
+        "speed up the import of Matplotlib and to better support multiprocessing.",
+        tmpdir, configdir)
+    return tmpdir
+
+
+@_logged_cached('CONFIGDIR=%s')
+def get_configdir():
+    """
+    Return the string path of the configuration directory.
+
+    The directory is chosen as follows:
+
+    1. If the MPLCONFIGDIR environment variable is supplied, choose that.
+    2. On Linux, follow the XDG specification and look first in
+       ``$XDG_CONFIG_HOME``, if defined, or ``$HOME/.config``.  On other
+       platforms, choose ``$HOME/.matplotlib``.
+    3. If the chosen directory exists and is writable, use that as the
+       configuration directory.
+    4. Else, create a temporary directory, and use it as the configuration
+       directory.
+    """
+    return _get_config_or_cache_dir(_get_xdg_config_dir)
+
+
+@_logged_cached('CACHEDIR=%s')
+def get_cachedir():
+    """
+    Return the string path of the cache directory.
+
+    The procedure used to find the directory is the same as for
+    `get_configdir`, except using ``$XDG_CACHE_HOME``/``$HOME/.cache`` instead.
+    """
+    return _get_config_or_cache_dir(_get_xdg_cache_dir)
+
+
+@_logged_cached('matplotlib data path: %s')
+def get_data_path():
+    """Return the path to Matplotlib data."""
+    return str(Path(__file__).with_name("mpl-data"))
+
+
+def matplotlib_fname():
+    """
+    Get the location of the config file.
+
+    The file location is determined in the following order
+
+    - ``$PWD/matplotlibrc``
+    - ``$MATPLOTLIBRC`` if it is not a directory
+    - ``$MATPLOTLIBRC/matplotlibrc``
+    - ``$MPLCONFIGDIR/matplotlibrc``
+    - On Linux,
+        - ``$XDG_CONFIG_HOME/matplotlib/matplotlibrc`` (if ``$XDG_CONFIG_HOME``
+          is defined)
+        - or ``$HOME/.config/matplotlib/matplotlibrc`` (if ``$XDG_CONFIG_HOME``
+          is not defined)
+    - On other platforms,
+      - ``$HOME/.matplotlib/matplotlibrc`` if ``$HOME`` is defined
+    - Lastly, it looks in ``$MATPLOTLIBDATA/matplotlibrc``, which should always
+      exist.
+    """
+
+    def gen_candidates():
+        # rely on down-stream code to make absolute.  This protects us
+        # from having to directly get the current working directory
+        # which can fail if the user has ended up with a cwd that is
+        # non-existent.
+        yield 'matplotlibrc'
+        try:
+            matplotlibrc = os.environ['MATPLOTLIBRC']
+        except KeyError:
+            pass
+        else:
+            yield matplotlibrc
+            yield os.path.join(matplotlibrc, 'matplotlibrc')
+        yield os.path.join(get_configdir(), 'matplotlibrc')
+        yield os.path.join(get_data_path(), 'matplotlibrc')
+
+    for fname in gen_candidates():
+        if os.path.exists(fname) and not os.path.isdir(fname):
+            return fname
+
+    raise RuntimeError("Could not find matplotlibrc file; your Matplotlib "
+                       "install is broken")
+
+
+# rcParams deprecated and automatically mapped to another key.
+# Values are tuples of (version, new_name, f_old2new, f_new2old).
+_deprecated_map = {}
+# rcParams deprecated; some can manually be mapped to another key.
+# Values are tuples of (version, new_name_or_None).
+_deprecated_ignore_map = {}
+# rcParams deprecated; can use None to suppress warnings; remain actually
+# listed in the rcParams.
+# Values are tuples of (version,)
+_deprecated_remain_as_none = {}
+
+
+@_docstring.Substitution(
+    "\n".join(map("- {}".format, sorted(rcsetup._validators, key=str.lower)))
+)
+class RcParams(MutableMapping, dict):
+    """
+    A dict-like key-value store for config parameters, including validation.
+
+    Validating functions are defined and associated with rc parameters in
+    :mod:`matplotlib.rcsetup`.
+
+    The list of rcParams is:
+
+    %s
+
+    See Also
+    --------
+    :ref:`customizing-with-matplotlibrc-files`
+    """
+
+    validate = rcsetup._validators
+
+    # validate values on the way in
+    def __init__(self, *args, **kwargs):
+        self.update(*args, **kwargs)
+
+    def _set(self, key, val):
+        """
+        Directly write data bypassing deprecation and validation logic.
+
+        Notes
+        -----
+        As end user or downstream library you almost always should use
+        ``rcParams[key] = val`` and not ``_set()``.
+
+        There are only very few special cases that need direct data access.
+        These cases previously used ``dict.__setitem__(rcParams, key, val)``,
+        which is now deprecated and replaced by ``rcParams._set(key, val)``.
+
+        Even though private, we guarantee API stability for ``rcParams._set``,
+        i.e. it is subject to Matplotlib's API and deprecation policy.
+
+        :meta public:
+        """
+        dict.__setitem__(self, key, val)
+
+    def _get(self, key):
+        """
+        Directly read data bypassing deprecation, backend and validation
+        logic.
+
+        Notes
+        -----
+        As end user or downstream library you almost always should use
+        ``val = rcParams[key]`` and not ``_get()``.
+
+        There are only very few special cases that need direct data access.
+        These cases previously used ``dict.__getitem__(rcParams, key, val)``,
+        which is now deprecated and replaced by ``rcParams._get(key)``.
+
+        Even though private, we guarantee API stability for ``rcParams._get``,
+        i.e. it is subject to Matplotlib's API and deprecation policy.
+
+        :meta public:
+        """
+        return dict.__getitem__(self, key)
+
+    def _update_raw(self, other_params):
+        """
+        Directly update the data from *other_params*, bypassing deprecation,
+        backend and validation logic on both sides.
+
+        This ``rcParams._update_raw(params)`` replaces the previous pattern
+        ``dict.update(rcParams, params)``.
+
+        Parameters
+        ----------
+        other_params : dict or `.RcParams`
+            The input mapping from which to update.
+        """
+        if isinstance(other_params, RcParams):
+            other_params = dict.items(other_params)
+        dict.update(self, other_params)
+
+    def _ensure_has_backend(self):
+        """
+        Ensure that a "backend" entry exists.
+
+        Normally, the default matplotlibrc file contains *no* entry for "backend" (the
+        corresponding line starts with ##, not #; we fill in _auto_backend_sentinel
+        in that case.  However, packagers can set a different default backend
+        (resulting in a normal `#backend: foo` line) in which case we should *not*
+        fill in _auto_backend_sentinel.
+        """
+        dict.setdefault(self, "backend", rcsetup._auto_backend_sentinel)
+
+    def __setitem__(self, key, val):
+        try:
+            if key in _deprecated_map:
+                version, alt_key, alt_val, inverse_alt = _deprecated_map[key]
+                _api.warn_deprecated(
+                    version, name=key, obj_type="rcparam", alternative=alt_key)
+                key = alt_key
+                val = alt_val(val)
+            elif key in _deprecated_remain_as_none and val is not None:
+                version, = _deprecated_remain_as_none[key]
+                _api.warn_deprecated(version, name=key, obj_type="rcparam")
+            elif key in _deprecated_ignore_map:
+                version, alt_key = _deprecated_ignore_map[key]
+                _api.warn_deprecated(
+                    version, name=key, obj_type="rcparam", alternative=alt_key)
+                return
+            elif key == 'backend':
+                if val is rcsetup._auto_backend_sentinel:
+                    if 'backend' in self:
+                        return
+            try:
+                cval = self.validate[key](val)
+            except ValueError as ve:
+                raise ValueError(f"Key {key}: {ve}") from None
+            self._set(key, cval)
+        except KeyError as err:
+            raise KeyError(
+                f"{key} is not a valid rc parameter (see rcParams.keys() for "
+                f"a list of valid parameters)") from err
+
+    def __getitem__(self, key):
+        if key in _deprecated_map:
+            version, alt_key, alt_val, inverse_alt = _deprecated_map[key]
+            _api.warn_deprecated(
+                version, name=key, obj_type="rcparam", alternative=alt_key)
+            return inverse_alt(self._get(alt_key))
+
+        elif key in _deprecated_ignore_map:
+            version, alt_key = _deprecated_ignore_map[key]
+            _api.warn_deprecated(
+                version, name=key, obj_type="rcparam", alternative=alt_key)
+            return self._get(alt_key) if alt_key else None
+
+        # In theory, this should only ever be used after the global rcParams
+        # has been set up, but better be safe e.g. in presence of breakpoints.
+        elif key == "backend" and self is globals().get("rcParams"):
+            val = self._get(key)
+            if val is rcsetup._auto_backend_sentinel:
+                from matplotlib import pyplot as plt
+                plt.switch_backend(rcsetup._auto_backend_sentinel)
+
+        return self._get(key)
+
+    def _get_backend_or_none(self):
+        """Get the requested backend, if any, without triggering resolution."""
+        backend = self._get("backend")
+        return None if backend is rcsetup._auto_backend_sentinel else backend
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        indent = len(class_name) + 1
+        with _api.suppress_matplotlib_deprecation_warning():
+            repr_split = pprint.pformat(dict(self), indent=1,
+                                        width=80 - indent).split('\n')
+        repr_indented = ('\n' + ' ' * indent).join(repr_split)
+        return f'{class_name}({repr_indented})'
+
+    def __str__(self):
+        return '\n'.join(map('{0[0]}: {0[1]}'.format, sorted(self.items())))
+
+    def __iter__(self):
+        """Yield sorted list of keys."""
+        with _api.suppress_matplotlib_deprecation_warning():
+            yield from sorted(dict.__iter__(self))
+
+    def __len__(self):
+        return dict.__len__(self)
+
+    def find_all(self, pattern):
+        """
+        Return the subset of this RcParams dictionary whose keys match,
+        using :func:`re.search`, the given ``pattern``.
+
+        .. note::
+
+            Changes to the returned dictionary are *not* propagated to
+            the parent RcParams dictionary.
+
+        """
+        pattern_re = re.compile(pattern)
+        return RcParams((key, value)
+                        for key, value in self.items()
+                        if pattern_re.search(key))
+
+    def copy(self):
+        """Copy this RcParams instance."""
+        rccopy = RcParams()
+        for k in self:  # Skip deprecations and revalidation.
+            rccopy._set(k, self._get(k))
+        return rccopy
+
+
+def rc_params(fail_on_error=False):
+    """Construct a `RcParams` instance from the default Matplotlib rc file."""
+    return rc_params_from_file(matplotlib_fname(), fail_on_error)
+
+
+@functools.cache
+def _get_ssl_context():
+    try:
+        import certifi
+    except ImportError:
+        _log.debug("Could not import certifi.")
+        return None
+    import ssl
+    return ssl.create_default_context(cafile=certifi.where())
+
+
+@contextlib.contextmanager
+def _open_file_or_url(fname):
+    if (isinstance(fname, str)
+            and fname.startswith(('http://', 'https://', 'ftp://', 'file:'))):
+        import urllib.request
+        ssl_ctx = _get_ssl_context()
+        if ssl_ctx is None:
+            _log.debug(
+                "Could not get certifi ssl context, https may not work."
+            )
+        with urllib.request.urlopen(fname, context=ssl_ctx) as f:
+            yield (line.decode('utf-8') for line in f)
+    else:
+        fname = os.path.expanduser(fname)
+        with open(fname, encoding='utf-8') as f:
+            yield f
+
+
+def _rc_params_in_file(fname, transform=lambda x: x, fail_on_error=False):
+    """
+    Construct a `RcParams` instance from file *fname*.
+
+    Unlike `rc_params_from_file`, the configuration class only contains the
+    parameters specified in the file (i.e. default values are not filled in).
+
+    Parameters
+    ----------
+    fname : path-like
+        The loaded file.
+    transform : callable, default: the identity function
+        A function called on each individual line of the file to transform it,
+        before further parsing.
+    fail_on_error : bool, default: False
+        Whether invalid entries should result in an exception or a warning.
+    """
+    import matplotlib as mpl
+    rc_temp = {}
+    with _open_file_or_url(fname) as fd:
+        try:
+            for line_no, line in enumerate(fd, 1):
+                line = transform(line)
+                strippedline = cbook._strip_comment(line)
+                if not strippedline:
+                    continue
+                tup = strippedline.split(':', 1)
+                if len(tup) != 2:
+                    _log.warning('Missing colon in file %r, line %d (%r)',
+                                 fname, line_no, line.rstrip('\n'))
+                    continue
+                key, val = tup
+                key = key.strip()
+                val = val.strip()
+                if val.startswith('"') and val.endswith('"'):
+                    val = val[1:-1]  # strip double quotes
+                if key in rc_temp:
+                    _log.warning('Duplicate key in file %r, line %d (%r)',
+                                 fname, line_no, line.rstrip('\n'))
+                rc_temp[key] = (val, line, line_no)
+        except UnicodeDecodeError:
+            _log.warning('Cannot decode configuration file %r as utf-8.',
+                         fname)
+            raise
+
+    config = RcParams()
+
+    for key, (val, line, line_no) in rc_temp.items():
+        if key in rcsetup._validators:
+            if fail_on_error:
+                config[key] = val  # try to convert to proper type or raise
+            else:
+                try:
+                    config[key] = val  # try to convert to proper type or skip
+                except Exception as msg:
+                    _log.warning('Bad value in file %r, line %d (%r): %s',
+                                 fname, line_no, line.rstrip('\n'), msg)
+        elif key in _deprecated_ignore_map:
+            version, alt_key = _deprecated_ignore_map[key]
+            _api.warn_deprecated(
+                version, name=key, alternative=alt_key, obj_type='rcparam',
+                addendum="Please update your matplotlibrc.")
+        else:
+            # __version__ must be looked up as an attribute to trigger the
+            # module-level __getattr__.
+            version = ('main' if '.post' in mpl.__version__
+                       else f'v{mpl.__version__}')
+            _log.warning("""
+Bad key %(key)s in file %(fname)s, line %(line_no)s (%(line)r)
+You probably need to get an updated matplotlibrc file from
+https://github.com/matplotlib/matplotlib/blob/%(version)s/lib/matplotlib/mpl-data/matplotlibrc
+or from the matplotlib source distribution""",
+                         dict(key=key, fname=fname, line_no=line_no,
+                              line=line.rstrip('\n'), version=version))
+    return config
+
+
+def rc_params_from_file(fname, fail_on_error=False, use_default_template=True):
+    """
+    Construct a `RcParams` from file *fname*.
+
+    Parameters
+    ----------
+    fname : str or path-like
+        A file with Matplotlib rc settings.
+    fail_on_error : bool
+        If True, raise an error when the parser fails to convert a parameter.
+    use_default_template : bool
+        If True, initialize with default parameters before updating with those
+        in the given file. If False, the configuration class only contains the
+        parameters specified in the file. (Useful for updating dicts.)
+    """
+    config_from_file = _rc_params_in_file(fname, fail_on_error=fail_on_error)
+
+    if not use_default_template:
+        return config_from_file
+
+    with _api.suppress_matplotlib_deprecation_warning():
+        config = RcParams({**rcParamsDefault, **config_from_file})
+
+    if "".join(config['text.latex.preamble']):
+        _log.info("""
+*****************************************************************
+You have the following UNSUPPORTED LaTeX preamble customizations:
+%s
+Please do not ask for support with these customizations active.
+*****************************************************************
+""", '\n'.join(config['text.latex.preamble']))
+    _log.debug('loaded rc file %s', fname)
+
+    return config
+
+
+rcParamsDefault = _rc_params_in_file(
+    cbook._get_data_path("matplotlibrc"),
+    # Strip leading comment.
+    transform=lambda line: line[1:] if line.startswith("#") else line,
+    fail_on_error=True)
+rcParamsDefault._update_raw(rcsetup._hardcoded_defaults)
+rcParamsDefault._ensure_has_backend()
+
+rcParams = RcParams()  # The global instance.
+rcParams._update_raw(rcParamsDefault)
+rcParams._update_raw(_rc_params_in_file(matplotlib_fname()))
+rcParamsOrig = rcParams.copy()
+with _api.suppress_matplotlib_deprecation_warning():
+    # This also checks that all rcParams are indeed listed in the template.
+    # Assigning to rcsetup.defaultParams is left only for backcompat.
+    defaultParams = rcsetup.defaultParams = {
+        # We want to resolve deprecated rcParams, but not backend...
+        key: [(rcsetup._auto_backend_sentinel if key == "backend" else
+               rcParamsDefault[key]),
+              validator]
+        for key, validator in rcsetup._validators.items()}
+if rcParams['axes.formatter.use_locale']:
+    locale.setlocale(locale.LC_ALL, '')
+
+
+def rc(group, **kwargs):
+    """
+    Set the current `.rcParams`.  *group* is the grouping for the rc, e.g.,
+    for ``lines.linewidth`` the group is ``lines``, for
+    ``axes.facecolor``, the group is ``axes``, and so on.  Group may
+    also be a list or tuple of group names, e.g., (*xtick*, *ytick*).
+    *kwargs* is a dictionary attribute name/value pairs, e.g.,::
+
+      rc('lines', linewidth=2, color='r')
+
+    sets the current `.rcParams` and is equivalent to::
+
+      rcParams['lines.linewidth'] = 2
+      rcParams['lines.color'] = 'r'
+
+    The following aliases are available to save typing for interactive users:
+
+    =====   =================
+    Alias   Property
+    =====   =================
+    'lw'    'linewidth'
+    'ls'    'linestyle'
+    'c'     'color'
+    'fc'    'facecolor'
+    'ec'    'edgecolor'
+    'mew'   'markeredgewidth'
+    'aa'    'antialiased'
+    =====   =================
+
+    Thus you could abbreviate the above call as::
+
+          rc('lines', lw=2, c='r')
+
+    Note you can use python's kwargs dictionary facility to store
+    dictionaries of default parameters.  e.g., you can customize the
+    font rc as follows::
+
+      font = {'family' : 'monospace',
+              'weight' : 'bold',
+              'size'   : 'larger'}
+      rc('font', **font)  # pass in the font dict as kwargs
+
+    This enables you to easily switch between several configurations.  Use
+    ``matplotlib.style.use('default')`` or :func:`~matplotlib.rcdefaults` to
+    restore the default `.rcParams` after changes.
+
+    Notes
+    -----
+    Similar functionality is available by using the normal dict interface, i.e.
+    ``rcParams.update({"lines.linewidth": 2, ...})`` (but ``rcParams.update``
+    does not support abbreviations or grouping).
+    """
+
+    aliases = {
+        'lw':  'linewidth',
+        'ls':  'linestyle',
+        'c':   'color',
+        'fc':  'facecolor',
+        'ec':  'edgecolor',
+        'mew': 'markeredgewidth',
+        'aa':  'antialiased',
+        }
+
+    if isinstance(group, str):
+        group = (group,)
+    for g in group:
+        for k, v in kwargs.items():
+            name = aliases.get(k) or k
+            key = f'{g}.{name}'
+            try:
+                rcParams[key] = v
+            except KeyError as err:
+                raise KeyError(('Unrecognized key "%s" for group "%s" and '
+                                'name "%s"') % (key, g, name)) from err
+
+
+def rcdefaults():
+    """
+    Restore the `.rcParams` from Matplotlib's internal default style.
+
+    Style-blacklisted `.rcParams` (defined in
+    ``matplotlib.style.core.STYLE_BLACKLIST``) are not updated.
+
+    See Also
+    --------
+    matplotlib.rc_file_defaults
+        Restore the `.rcParams` from the rc file originally loaded by
+        Matplotlib.
+    matplotlib.style.use
+        Use a specific style file.  Call ``style.use('default')`` to restore
+        the default style.
+    """
+    # Deprecation warnings were already handled when creating rcParamsDefault,
+    # no need to reemit them here.
+    with _api.suppress_matplotlib_deprecation_warning():
+        from .style.core import STYLE_BLACKLIST
+        rcParams.clear()
+        rcParams.update({k: v for k, v in rcParamsDefault.items()
+                         if k not in STYLE_BLACKLIST})
+
+
+def rc_file_defaults():
+    """
+    Restore the `.rcParams` from the original rc file loaded by Matplotlib.
+
+    Style-blacklisted `.rcParams` (defined in
+    ``matplotlib.style.core.STYLE_BLACKLIST``) are not updated.
+    """
+    # Deprecation warnings were already handled when creating rcParamsOrig, no
+    # need to reemit them here.
+    with _api.suppress_matplotlib_deprecation_warning():
+        from .style.core import STYLE_BLACKLIST
+        rcParams.update({k: rcParamsOrig[k] for k in rcParamsOrig
+                         if k not in STYLE_BLACKLIST})
+
+
+def rc_file(fname, *, use_default_template=True):
+    """
+    Update `.rcParams` from file.
+
+    Style-blacklisted `.rcParams` (defined in
+    ``matplotlib.style.core.STYLE_BLACKLIST``) are not updated.
+
+    Parameters
+    ----------
+    fname : str or path-like
+        A file with Matplotlib rc settings.
+
+    use_default_template : bool
+        If True, initialize with default parameters before updating with those
+        in the given file. If False, the current configuration persists
+        and only the parameters specified in the file are updated.
+    """
+    # Deprecation warnings were already handled in rc_params_from_file, no need
+    # to reemit them here.
+    with _api.suppress_matplotlib_deprecation_warning():
+        from .style.core import STYLE_BLACKLIST
+        rc_from_file = rc_params_from_file(
+            fname, use_default_template=use_default_template)
+        rcParams.update({k: rc_from_file[k] for k in rc_from_file
+                         if k not in STYLE_BLACKLIST})
+
+
+@contextlib.contextmanager
+def rc_context(rc=None, fname=None):
+    """
+    Return a context manager for temporarily changing rcParams.
+
+    The :rc:`backend` will not be reset by the context manager.
+
+    rcParams changed both through the context manager invocation and
+    in the body of the context will be reset on context exit.
+
+    Parameters
+    ----------
+    rc : dict
+        The rcParams to temporarily set.
+    fname : str or path-like
+        A file with Matplotlib rc settings. If both *fname* and *rc* are given,
+        settings from *rc* take precedence.
+
+    See Also
+    --------
+    :ref:`customizing-with-matplotlibrc-files`
+
+    Examples
+    --------
+    Passing explicit values via a dict::
+
+        with mpl.rc_context({'interactive': False}):
+            fig, ax = plt.subplots()
+            ax.plot(range(3), range(3))
+            fig.savefig('example.png')
+            plt.close(fig)
+
+    Loading settings from a file::
+
+         with mpl.rc_context(fname='print.rc'):
+             plt.plot(x, y)  # uses 'print.rc'
+
+    Setting in the context body::
+
+        with mpl.rc_context():
+            # will be reset
+            mpl.rcParams['lines.linewidth'] = 5
+            plt.plot(x, y)
+
+    """
+    orig = dict(rcParams.copy())
+    del orig['backend']
+    try:
+        if fname:
+            rc_file(fname)
+        if rc:
+            rcParams.update(rc)
+        yield
+    finally:
+        rcParams._update_raw(orig)  # Revert to the original rcs.
+
+
+def use(backend, *, force=True):
+    """
+    Select the backend used for rendering and GUI integration.
+
+    If pyplot is already imported, `~matplotlib.pyplot.switch_backend` is used
+    and if the new backend is different than the current backend, all Figures
+    will be closed.
+
+    Parameters
+    ----------
+    backend : str
+        The backend to switch to.  This can either be one of the standard
+        backend names, which are case-insensitive:
+
+        - interactive backends:
+          GTK3Agg, GTK3Cairo, GTK4Agg, GTK4Cairo, MacOSX, nbAgg, notebook, QtAgg,
+          QtCairo, TkAgg, TkCairo, WebAgg, WX, WXAgg, WXCairo, Qt5Agg, Qt5Cairo
+
+        - non-interactive backends:
+          agg, cairo, pdf, pgf, ps, svg, template
+
+        or a string of the form: ``module://my.module.name``.
+
+        notebook is a synonym for nbAgg.
+
+        Switching to an interactive backend is not possible if an unrelated
+        event loop has already been started (e.g., switching to GTK3Agg if a
+        TkAgg window has already been opened).  Switching to a non-interactive
+        backend is always possible.
+
+    force : bool, default: True
+        If True (the default), raise an `ImportError` if the backend cannot be
+        set up (either because it fails to import, or because an incompatible
+        GUI interactive framework is already running); if False, silently
+        ignore the failure.
+
+    See Also
+    --------
+    :ref:`backends`
+    matplotlib.get_backend
+    matplotlib.pyplot.switch_backend
+
+    """
+    name = rcsetup.validate_backend(backend)
+    # don't (prematurely) resolve the "auto" backend setting
+    if rcParams._get_backend_or_none() == name:
+        # Nothing to do if the requested backend is already set
+        pass
+    else:
+        # if pyplot is not already imported, do not import it.  Doing
+        # so may trigger a `plt.switch_backend` to the _default_ backend
+        # before we get a chance to change to the one the user just requested
+        plt = sys.modules.get('matplotlib.pyplot')
+        # if pyplot is imported, then try to change backends
+        if plt is not None:
+            try:
+                # we need this import check here to re-raise if the
+                # user does not have the libraries to support their
+                # chosen backend installed.
+                plt.switch_backend(name)
+            except ImportError:
+                if force:
+                    raise
+        # if we have not imported pyplot, then we can set the rcParam
+        # value which will be respected when the user finally imports
+        # pyplot
+        else:
+            rcParams['backend'] = backend
+    # if the user has asked for a given backend, do not helpfully
+    # fallback
+    rcParams['backend_fallback'] = False
+
+
+if os.environ.get('MPLBACKEND'):
+    rcParams['backend'] = os.environ.get('MPLBACKEND')
+
+
+def get_backend(*, auto_select=True):
+    """
+    Return the name of the current backend.
+
+    Parameters
+    ----------
+    auto_select : bool, default: True
+        Whether to trigger backend resolution if no backend has been
+        selected so far. If True, this ensures that a valid backend
+        is returned. If False, this returns None if no backend has been
+        selected so far.
+
+        .. versionadded:: 3.10
+
+        .. admonition:: Provisional
+
+           The *auto_select* flag is provisional. It may be changed or removed
+           without prior warning.
+
+    See Also
+    --------
+    matplotlib.use
+    """
+    if auto_select:
+        return rcParams['backend']
+    else:
+        backend = rcParams._get('backend')
+        if backend is rcsetup._auto_backend_sentinel:
+            return None
+        else:
+            return backend
+
+
+def interactive(b):
+    """
+    Set whether to redraw after every plotting command (e.g. `.pyplot.xlabel`).
+    """
+    rcParams['interactive'] = b
+
+
+def is_interactive():
+    """
+    Return whether to redraw after every plotting command.
+
+    .. note::
+
+        This function is only intended for use in backends. End users should
+        use `.pyplot.isinteractive` instead.
+    """
+    return rcParams['interactive']
+
+
+def _val_or_rc(val, rc_name):
+    """
+    If *val* is None, return ``mpl.rcParams[rc_name]``, otherwise return val.
+    """
+    return val if val is not None else rcParams[rc_name]
+
+
+def _init_tests():
+    # The version of FreeType to install locally for running the tests. This must match
+    # the value in `meson.build`.
+    LOCAL_FREETYPE_VERSION = '2.6.1'
+
+    from matplotlib import ft2font
+    if (ft2font.__freetype_version__ != LOCAL_FREETYPE_VERSION or
+            ft2font.__freetype_build_type__ != 'local'):
+        _log.warning(
+            "Matplotlib is not built with the correct FreeType version to run tests.  "
+            "Rebuild without setting system-freetype=true in Meson setup options.  "
+            "Expect many image comparison failures below.  "
+            "Expected freetype version %s.  "
+            "Found freetype version %s.  "
+            "Freetype build type is %slocal.",
+            LOCAL_FREETYPE_VERSION,
+            ft2font.__freetype_version__,
+            "" if ft2font.__freetype_build_type__ == 'local' else "not ")
+
+
+def _replacer(data, value):
+    """
+    Either returns ``data[value]`` or passes ``data`` back, converts either to
+    a sequence.
+    """
+    try:
+        # if key isn't a string don't bother
+        if isinstance(value, str):
+            # try to use __getitem__
+            value = data[value]
+    except Exception:
+        # key does not exist, silently fall back to key
+        pass
+    return cbook.sanitize_sequence(value)
+
+
+def _label_from_arg(y, default_name):
+    try:
+        return y.name
+    except AttributeError:
+        if isinstance(default_name, str):
+            return default_name
+    return None
+
+
+def _add_data_doc(docstring, replace_names):
+    """
+    Add documentation for a *data* field to the given docstring.
+
+    Parameters
+    ----------
+    docstring : str
+        The input docstring.
+    replace_names : list of str or None
+        The list of parameter names which arguments should be replaced by
+        ``data[name]`` (if ``data[name]`` does not throw an exception).  If
+        None, replacement is attempted for all arguments.
+
+    Returns
+    -------
+    str
+        The augmented docstring.
+    """
+    if (docstring is None
+            or replace_names is not None and len(replace_names) == 0):
+        return docstring
+    docstring = inspect.cleandoc(docstring)
+
+    data_doc = ("""\
+    If given, all parameters also accept a string ``s``, which is
+    interpreted as ``data[s]`` if ``s`` is a key in ``data``."""
+                if replace_names is None else f"""\
+    If given, the following parameters also accept a string ``s``, which is
+    interpreted as ``data[s]`` if ``s`` is a key in ``data``:
+
+    {', '.join(map('*{}*'.format, replace_names))}""")
+    # using string replacement instead of formatting has the advantages
+    # 1) simpler indent handling
+    # 2) prevent problems with formatting characters '{', '%' in the docstring
+    if _log.level <= logging.DEBUG:
+        # test_data_parameter_replacement() tests against these log messages
+        # make sure to keep message and test in sync
+        if "data : indexable object, optional" not in docstring:
+            _log.debug("data parameter docstring error: no data parameter")
+        if 'DATA_PARAMETER_PLACEHOLDER' not in docstring:
+            _log.debug("data parameter docstring error: missing placeholder")
+    return docstring.replace('    DATA_PARAMETER_PLACEHOLDER', data_doc)
+
+
+def _preprocess_data(func=None, *, replace_names=None, label_namer=None):
+    """
+    A decorator to add a 'data' kwarg to a function.
+
+    When applied::
+
+        @_preprocess_data()
+        def func(ax, *args, **kwargs): ...
+
+    the signature is modified to ``decorated(ax, *args, data=None, **kwargs)``
+    with the following behavior:
+
+    - if called with ``data=None``, forward the other arguments to ``func``;
+    - otherwise, *data* must be a mapping; for any argument passed in as a
+      string ``name``, replace the argument by ``data[name]`` (if this does not
+      throw an exception), then forward the arguments to ``func``.
+
+    In either case, any argument that is a `MappingView` is also converted to a
+    list.
+
+    Parameters
+    ----------
+    replace_names : list of str or None, default: None
+        The list of parameter names for which lookup into *data* should be
+        attempted. If None, replacement is attempted for all arguments.
+    label_namer : str, default: None
+        If set e.g. to "namer" (which must be a kwarg in the function's
+        signature -- not as ``**kwargs``), if the *namer* argument passed in is
+        a (string) key of *data* and no *label* kwarg is passed, then use the
+        (string) value of the *namer* as *label*. ::
+
+            @_preprocess_data(label_namer="foo")
+            def func(foo, label=None): ...
+
+            func("key", data={"key": value})
+            # is equivalent to
+            func.__wrapped__(value, label="key")
+    """
+
+    if func is None:  # Return the actual decorator.
+        return functools.partial(
+            _preprocess_data,
+            replace_names=replace_names, label_namer=label_namer)
+
+    sig = inspect.signature(func)
+    varargs_name = None
+    varkwargs_name = None
+    arg_names = []
+    params = list(sig.parameters.values())
+    for p in params:
+        if p.kind is Parameter.VAR_POSITIONAL:
+            varargs_name = p.name
+        elif p.kind is Parameter.VAR_KEYWORD:
+            varkwargs_name = p.name
+        else:
+            arg_names.append(p.name)
+    data_param = Parameter("data", Parameter.KEYWORD_ONLY, default=None)
+    if varkwargs_name:
+        params.insert(-1, data_param)
+    else:
+        params.append(data_param)
+    new_sig = sig.replace(parameters=params)
+    arg_names = arg_names[1:]  # remove the first "ax" / self arg
+
+    assert {*arg_names}.issuperset(replace_names or []) or varkwargs_name, (
+        "Matplotlib internal error: invalid replace_names "
+        f"({replace_names!r}) for {func.__name__!r}")
+    assert label_namer is None or label_namer in arg_names, (
+        "Matplotlib internal error: invalid label_namer "
+        f"({label_namer!r}) for {func.__name__!r}")
+
+    @functools.wraps(func)
+    def inner(ax, *args, data=None, **kwargs):
+        if data is None:
+            return func(
+                ax,
+                *map(cbook.sanitize_sequence, args),
+                **{k: cbook.sanitize_sequence(v) for k, v in kwargs.items()})
+
+        bound = new_sig.bind(ax, *args, **kwargs)
+        auto_label = (bound.arguments.get(label_namer)
+                      or bound.kwargs.get(label_namer))
+
+        for k, v in bound.arguments.items():
+            if k == varkwargs_name:
+                for k1, v1 in v.items():
+                    if replace_names is None or k1 in replace_names:
+                        v[k1] = _replacer(data, v1)
+            elif k == varargs_name:
+                if replace_names is None:
+                    bound.arguments[k] = tuple(_replacer(data, v1) for v1 in v)
+            else:
+                if replace_names is None or k in replace_names:
+                    bound.arguments[k] = _replacer(data, v)
+
+        new_args = bound.args
+        new_kwargs = bound.kwargs
+
+        args_and_kwargs = {**bound.arguments, **bound.kwargs}
+        if label_namer and "label" not in args_and_kwargs:
+            new_kwargs["label"] = _label_from_arg(
+                args_and_kwargs.get(label_namer), auto_label)
+
+        return func(*new_args, **new_kwargs)
+
+    inner.__doc__ = _add_data_doc(inner.__doc__, replace_names)
+    inner.__signature__ = new_sig
+    return inner
+
+
+_log.debug('interactive is %s', is_interactive())
+_log.debug('platform is %s', sys.platform)
+
+
+@_api.deprecated("3.10", alternative="matplotlib.cbook.sanitize_sequence")
+def sanitize_sequence(data):
+    return cbook.sanitize_sequence(data)
+
+
+@_api.deprecated("3.10", alternative="matplotlib.rcsetup.validate_backend")
+def validate_backend(s):
+    return rcsetup.validate_backend(s)
+
+
+# workaround: we must defer colormaps import to after loading rcParams, because
+# colormap creation depends on rcParams
+from matplotlib.cm import _colormaps as colormaps  # noqa: E402
+from matplotlib.cm import _multivar_colormaps as multivar_colormaps  # noqa: E402
+from matplotlib.cm import _bivar_colormaps as bivar_colormaps  # noqa: E402
+from matplotlib.colors import _color_sequences as color_sequences  # noqa: E402

infer_4_37_2/lib/python3.10/site-packages/matplotlib/_c_internal_utils.pyi

@@ -0,0 +1,8 @@
+def display_is_valid() -> bool: ...
+def xdisplay_is_valid() -> bool: ...
+
+def Win32_GetForegroundWindow() -> int | None: ...
+def Win32_SetForegroundWindow(hwnd: int) -> None: ...
+def Win32_SetProcessDpiAwareness_max() -> None: ...
+def Win32_SetCurrentProcessExplicitAppUserModelID(appid: str) -> None: ...
+def Win32_GetCurrentProcessExplicitAppUserModelID() -> str | None: ...

infer_4_37_2/lib/python3.10/site-packages/matplotlib/_cm_multivar.py

@@ -0,0 +1,166 @@
+# auto-generated by https://github.com/trygvrad/multivariate_colormaps
+# date: 2024-05-28
+
+from .colors import LinearSegmentedColormap, MultivarColormap
+import matplotlib as mpl
+_LUTSIZE = mpl.rcParams['image.lut']
+
+_2VarAddA0_data = [[0.000, 0.000, 0.000],
+                   [0.020, 0.026, 0.031],
+                   [0.049, 0.068, 0.085],
+                   [0.075, 0.107, 0.135],
+                   [0.097, 0.144, 0.183],
+                   [0.116, 0.178, 0.231],
+                   [0.133, 0.212, 0.279],
+                   [0.148, 0.244, 0.326],
+                   [0.161, 0.276, 0.374],
+                   [0.173, 0.308, 0.422],
+                   [0.182, 0.339, 0.471],
+                   [0.190, 0.370, 0.521],
+                   [0.197, 0.400, 0.572],
+                   [0.201, 0.431, 0.623],
+                   [0.204, 0.461, 0.675],
+                   [0.204, 0.491, 0.728],
+                   [0.202, 0.520, 0.783],
+                   [0.197, 0.549, 0.838],
+                   [0.187, 0.577, 0.895]]
+
+_2VarAddA1_data = [[0.000, 0.000, 0.000],
+                   [0.030, 0.023, 0.018],
+                   [0.079, 0.060, 0.043],
+                   [0.125, 0.093, 0.065],
+                   [0.170, 0.123, 0.083],
+                   [0.213, 0.151, 0.098],
+                   [0.255, 0.177, 0.110],
+                   [0.298, 0.202, 0.120],
+                   [0.341, 0.226, 0.128],
+                   [0.384, 0.249, 0.134],
+                   [0.427, 0.271, 0.138],
+                   [0.472, 0.292, 0.141],
+                   [0.517, 0.313, 0.142],
+                   [0.563, 0.333, 0.141],
+                   [0.610, 0.353, 0.139],
+                   [0.658, 0.372, 0.134],
+                   [0.708, 0.390, 0.127],
+                   [0.759, 0.407, 0.118],
+                   [0.813, 0.423, 0.105]]
+
+_2VarSubA0_data = [[1.000, 1.000, 1.000],
+                   [0.959, 0.973, 0.986],
+                   [0.916, 0.948, 0.974],
+                   [0.874, 0.923, 0.965],
+                   [0.832, 0.899, 0.956],
+                   [0.790, 0.875, 0.948],
+                   [0.748, 0.852, 0.940],
+                   [0.707, 0.829, 0.934],
+                   [0.665, 0.806, 0.927],
+                   [0.624, 0.784, 0.921],
+                   [0.583, 0.762, 0.916],
+                   [0.541, 0.740, 0.910],
+                   [0.500, 0.718, 0.905],
+                   [0.457, 0.697, 0.901],
+                   [0.414, 0.675, 0.896],
+                   [0.369, 0.652, 0.892],
+                   [0.320, 0.629, 0.888],
+                   [0.266, 0.604, 0.884],
+                   [0.199, 0.574, 0.881]]
+
+_2VarSubA1_data = [[1.000, 1.000, 1.000],
+                   [0.982, 0.967, 0.955],
+                   [0.966, 0.935, 0.908],
+                   [0.951, 0.902, 0.860],
+                   [0.937, 0.870, 0.813],
+                   [0.923, 0.838, 0.765],
+                   [0.910, 0.807, 0.718],
+                   [0.898, 0.776, 0.671],
+                   [0.886, 0.745, 0.624],
+                   [0.874, 0.714, 0.577],
+                   [0.862, 0.683, 0.530],
+                   [0.851, 0.653, 0.483],
+                   [0.841, 0.622, 0.435],
+                   [0.831, 0.592, 0.388],
+                   [0.822, 0.561, 0.340],
+                   [0.813, 0.530, 0.290],
+                   [0.806, 0.498, 0.239],
+                   [0.802, 0.464, 0.184],
+                   [0.801, 0.426, 0.119]]
+
+_3VarAddA0_data = [[0.000, 0.000, 0.000],
+                   [0.018, 0.023, 0.028],
+                   [0.040, 0.056, 0.071],
+                   [0.059, 0.087, 0.110],
+                   [0.074, 0.114, 0.147],
+                   [0.086, 0.139, 0.183],
+                   [0.095, 0.163, 0.219],
+                   [0.101, 0.187, 0.255],
+                   [0.105, 0.209, 0.290],
+                   [0.107, 0.230, 0.326],
+                   [0.105, 0.251, 0.362],
+                   [0.101, 0.271, 0.398],
+                   [0.091, 0.291, 0.434],
+                   [0.075, 0.309, 0.471],
+                   [0.046, 0.325, 0.507],
+                   [0.021, 0.341, 0.546],
+                   [0.021, 0.363, 0.584],
+                   [0.022, 0.385, 0.622],
+                   [0.023, 0.408, 0.661]]
+
+_3VarAddA1_data = [[0.000, 0.000, 0.000],
+                   [0.020, 0.024, 0.016],
+                   [0.047, 0.058, 0.034],
+                   [0.072, 0.088, 0.048],
+                   [0.093, 0.116, 0.059],
+                   [0.113, 0.142, 0.067],
+                   [0.131, 0.167, 0.071],
+                   [0.149, 0.190, 0.074],
+                   [0.166, 0.213, 0.074],
+                   [0.182, 0.235, 0.072],
+                   [0.198, 0.256, 0.068],
+                   [0.215, 0.276, 0.061],
+                   [0.232, 0.296, 0.051],
+                   [0.249, 0.314, 0.037],
+                   [0.270, 0.330, 0.018],
+                   [0.288, 0.347, 0.000],
+                   [0.302, 0.369, 0.000],
+                   [0.315, 0.391, 0.000],
+                   [0.328, 0.414, 0.000]]
+
+_3VarAddA2_data = [[0.000, 0.000, 0.000],
+                   [0.029, 0.020, 0.023],
+                   [0.072, 0.045, 0.055],
+                   [0.111, 0.067, 0.084],
+                   [0.148, 0.085, 0.109],
+                   [0.184, 0.101, 0.133],
+                   [0.219, 0.115, 0.155],
+                   [0.254, 0.127, 0.176],
+                   [0.289, 0.138, 0.195],
+                   [0.323, 0.147, 0.214],
+                   [0.358, 0.155, 0.232],
+                   [0.393, 0.161, 0.250],
+                   [0.429, 0.166, 0.267],
+                   [0.467, 0.169, 0.283],
+                   [0.507, 0.168, 0.298],
+                   [0.546, 0.168, 0.313],
+                   [0.580, 0.172, 0.328],
+                   [0.615, 0.175, 0.341],
+                   [0.649, 0.178, 0.355]]
+
+cmaps = {
+    name: LinearSegmentedColormap.from_list(name, data, _LUTSIZE) for name, data in [
+        ('2VarAddA0', _2VarAddA0_data),
+        ('2VarAddA1', _2VarAddA1_data),
+        ('2VarSubA0', _2VarSubA0_data),
+        ('2VarSubA1', _2VarSubA1_data),
+        ('3VarAddA0', _3VarAddA0_data),
+        ('3VarAddA1', _3VarAddA1_data),
+        ('3VarAddA2', _3VarAddA2_data),
+    ]}
+
+cmap_families = {
+    '2VarAddA': MultivarColormap([cmaps[f'2VarAddA{i}'] for i in range(2)],
+                                 'sRGB_add', name='2VarAddA'),
+    '2VarSubA': MultivarColormap([cmaps[f'2VarSubA{i}'] for i in range(2)],
+                                 'sRGB_sub', name='2VarSubA'),
+    '3VarAddA': MultivarColormap([cmaps[f'3VarAddA{i}'] for i in range(3)],
+                                 'sRGB_add', name='3VarAddA'),
+}

infer_4_37_2/lib/python3.10/site-packages/matplotlib/_tight_bbox.py

@@ -0,0 +1,84 @@
+"""
+Helper module for the *bbox_inches* parameter in `.Figure.savefig`.
+"""
+
+from matplotlib.transforms import Bbox, TransformedBbox, Affine2D
+
+
+def adjust_bbox(fig, bbox_inches, fixed_dpi=None):
+    """
+    Temporarily adjust the figure so that only the specified area
+    (bbox_inches) is saved.
+
+    It modifies fig.bbox, fig.bbox_inches,
+    fig.transFigure._boxout, and fig.patch.  While the figure size
+    changes, the scale of the original figure is conserved.  A
+    function which restores the original values are returned.
+    """
+    origBbox = fig.bbox
+    origBboxInches = fig.bbox_inches
+    _boxout = fig.transFigure._boxout
+
+    old_aspect = []
+    locator_list = []
+    sentinel = object()
+    for ax in fig.axes:
+        locator = ax.get_axes_locator()
+        if locator is not None:
+            ax.apply_aspect(locator(ax, None))
+        locator_list.append(locator)
+        current_pos = ax.get_position(original=False).frozen()
+        ax.set_axes_locator(lambda a, r, _pos=current_pos: _pos)
+        # override the method that enforces the aspect ratio on the Axes
+        if 'apply_aspect' in ax.__dict__:
+            old_aspect.append(ax.apply_aspect)
+        else:
+            old_aspect.append(sentinel)
+        ax.apply_aspect = lambda pos=None: None
+
+    def restore_bbox():
+        for ax, loc, aspect in zip(fig.axes, locator_list, old_aspect):
+            ax.set_axes_locator(loc)
+            if aspect is sentinel:
+                # delete our no-op function which un-hides the original method
+                del ax.apply_aspect
+            else:
+                ax.apply_aspect = aspect
+
+        fig.bbox = origBbox
+        fig.bbox_inches = origBboxInches
+        fig.transFigure._boxout = _boxout
+        fig.transFigure.invalidate()
+        fig.patch.set_bounds(0, 0, 1, 1)
+
+    if fixed_dpi is None:
+        fixed_dpi = fig.dpi
+    tr = Affine2D().scale(fixed_dpi)
+    dpi_scale = fixed_dpi / fig.dpi
+
+    fig.bbox_inches = Bbox.from_bounds(0, 0, *bbox_inches.size)
+    x0, y0 = tr.transform(bbox_inches.p0)
+    w1, h1 = fig.bbox.size * dpi_scale
+    fig.transFigure._boxout = Bbox.from_bounds(-x0, -y0, w1, h1)
+    fig.transFigure.invalidate()
+
+    fig.bbox = TransformedBbox(fig.bbox_inches, tr)
+
+    fig.patch.set_bounds(x0 / w1, y0 / h1,
+                         fig.bbox.width / w1, fig.bbox.height / h1)
+
+    return restore_bbox
+
+
+def process_figure_for_rasterizing(fig, bbox_inches_restore, fixed_dpi=None):
+    """
+    A function that needs to be called when figure dpi changes during the
+    drawing (e.g., rasterizing).  It recovers the bbox and re-adjust it with
+    the new dpi.
+    """
+
+    bbox_inches, restore_bbox = bbox_inches_restore
+    restore_bbox()
+    r = adjust_bbox(fig, bbox_inches, fixed_dpi)
+
+    return bbox_inches, r

infer_4_37_2/lib/python3.10/site-packages/matplotlib/artist.pyi

@@ -0,0 +1,199 @@
+from .axes._base import _AxesBase
+from .backend_bases import RendererBase, MouseEvent
+from .figure import Figure, SubFigure
+from .path import Path
+from .patches import Patch
+from .patheffects import AbstractPathEffect
+from .transforms import (
+    BboxBase,
+    Bbox,
+    Transform,
+    TransformedPatchPath,
+    TransformedPath,
+)
+
+import numpy as np
+
+from collections.abc import Callable, Iterable
+from typing import Any, Literal, NamedTuple, TextIO, overload, TypeVar
+from numpy.typing import ArrayLike
+
+_T_Artist = TypeVar("_T_Artist", bound=Artist)
+
+def allow_rasterization(draw): ...
+
+class _XYPair(NamedTuple):
+    x: ArrayLike
+    y: ArrayLike
+
+class _Unset: ...
+
+class Artist:
+    zorder: float
+    stale_callback: Callable[[Artist, bool], None] | None
+    @property
+    def figure(self) -> Figure | SubFigure: ...
+    clipbox: BboxBase | None
+    def __init__(self) -> None: ...
+    def remove(self) -> None: ...
+    def have_units(self) -> bool: ...
+    # TODO units
+    def convert_xunits(self, x): ...
+    def convert_yunits(self, y): ...
+    @property
+    def axes(self) -> _AxesBase | None: ...
+    @axes.setter
+    def axes(self, new_axes: _AxesBase | None) -> None: ...
+    @property
+    def stale(self) -> bool: ...
+    @stale.setter
+    def stale(self, val: bool) -> None: ...
+    def get_window_extent(self, renderer: RendererBase | None = ...) -> Bbox: ...
+    def get_tightbbox(self, renderer: RendererBase | None = ...) -> Bbox | None: ...
+    def add_callback(self, func: Callable[[Artist], Any]) -> int: ...
+    def remove_callback(self, oid: int) -> None: ...
+    def pchanged(self) -> None: ...
+    def is_transform_set(self) -> bool: ...
+    def set_transform(self, t: Transform | None) -> None: ...
+    def get_transform(self) -> Transform: ...
+    def get_children(self) -> list[Artist]: ...
+    # TODO can these dicts be type narrowed? e.g. str keys
+    def contains(self, mouseevent: MouseEvent) -> tuple[bool, dict[Any, Any]]: ...
+    def pickable(self) -> bool: ...
+    def pick(self, mouseevent: MouseEvent) -> None: ...
+    def set_picker(
+        self,
+        picker: None
+        | bool
+        | float
+        | Callable[[Artist, MouseEvent], tuple[bool, dict[Any, Any]]],
+    ) -> None: ...
+    def get_picker(
+        self,
+    ) -> None | bool | float | Callable[
+        [Artist, MouseEvent], tuple[bool, dict[Any, Any]]
+    ]: ...
+    def get_url(self) -> str | None: ...
+    def set_url(self, url: str | None) -> None: ...
+    def get_gid(self) -> str | None: ...
+    def set_gid(self, gid: str | None) -> None: ...
+    def get_snap(self) -> bool | None: ...
+    def set_snap(self, snap: bool | None) -> None: ...
+    def get_sketch_params(self) -> tuple[float, float, float] | None: ...
+    def set_sketch_params(
+        self,
+        scale: float | None = ...,
+        length: float | None = ...,
+        randomness: float | None = ...,
+    ) -> None: ...
+    def set_path_effects(self, path_effects: list[AbstractPathEffect]) -> None: ...
+    def get_path_effects(self) -> list[AbstractPathEffect]: ...
+    @overload
+    def get_figure(self, root: Literal[True]) -> Figure | None: ...
+    @overload
+    def get_figure(self, root: Literal[False]) -> Figure | SubFigure | None: ...
+    @overload
+    def get_figure(self, root: bool = ...) -> Figure | SubFigure | None: ...
+    def set_figure(self, fig: Figure | SubFigure) -> None: ...
+    def set_clip_box(self, clipbox: BboxBase | None) -> None: ...
+    def set_clip_path(
+        self,
+        path: Patch | Path | TransformedPath | TransformedPatchPath | None,
+        transform: Transform | None = ...,
+    ) -> None: ...
+    def get_alpha(self) -> float | None: ...
+    def get_visible(self) -> bool: ...
+    def get_animated(self) -> bool: ...
+    def get_in_layout(self) -> bool: ...
+    def get_clip_on(self) -> bool: ...
+    def get_clip_box(self) -> Bbox | None: ...
+    def get_clip_path(
+        self,
+    ) -> Patch | Path | TransformedPath | TransformedPatchPath | None: ...
+    def get_transformed_clip_path_and_affine(
+        self,
+    ) -> tuple[None, None] | tuple[Path, Transform]: ...
+    def set_clip_on(self, b: bool) -> None: ...
+    def get_rasterized(self) -> bool: ...
+    def set_rasterized(self, rasterized: bool) -> None: ...
+    def get_agg_filter(self) -> Callable[[ArrayLike, float], tuple[np.ndarray, float, float]] | None: ...
+    def set_agg_filter(
+        self, filter_func: Callable[[ArrayLike, float], tuple[np.ndarray, float, float]] | None
+    ) -> None: ...
+    def draw(self, renderer: RendererBase) -> None: ...
+    def set_alpha(self, alpha: float | None) -> None: ...
+    def set_visible(self, b: bool) -> None: ...
+    def set_animated(self, b: bool) -> None: ...
+    def set_in_layout(self, in_layout: bool) -> None: ...
+    def get_label(self) -> object: ...
+    def set_label(self, s: object) -> None: ...
+    def get_zorder(self) -> float: ...
+    def set_zorder(self, level: float) -> None: ...
+    @property
+    def sticky_edges(self) -> _XYPair: ...
+    def update_from(self, other: Artist) -> None: ...
+    def properties(self) -> dict[str, Any]: ...
+    def update(self, props: dict[str, Any]) -> list[Any]: ...
+    def _internal_update(self, kwargs: Any) -> list[Any]: ...
+    def set(self, **kwargs: Any) -> list[Any]: ...
+
+    @overload
+    def findobj(
+        self,
+        match: None | Callable[[Artist], bool] = ...,
+        include_self: bool = ...,
+    ) -> list[Artist]: ...
+
+    @overload
+    def findobj(
+        self,
+        match: type[_T_Artist],
+        include_self: bool = ...,
+    ) -> list[_T_Artist]: ...
+
+    def get_cursor_data(self, event: MouseEvent) -> Any: ...
+    def format_cursor_data(self, data: Any) -> str: ...
+    def get_mouseover(self) -> bool: ...
+    def set_mouseover(self, mouseover: bool) -> None: ...
+    @property
+    def mouseover(self) -> bool: ...
+    @mouseover.setter
+    def mouseover(self, mouseover: bool) -> None: ...
+
+class ArtistInspector:
+    oorig: Artist | type[Artist]
+    o: type[Artist]
+    aliasd: dict[str, set[str]]
+    def __init__(
+        self, o: Artist | type[Artist] | Iterable[Artist | type[Artist]]
+    ) -> None: ...
+    def get_aliases(self) -> dict[str, set[str]]: ...
+    def get_valid_values(self, attr: str) -> str | None: ...
+    def get_setters(self) -> list[str]: ...
+    @staticmethod
+    def number_of_parameters(func: Callable) -> int: ...
+    @staticmethod
+    def is_alias(method: Callable) -> bool: ...
+    def aliased_name(self, s: str) -> str: ...
+    def aliased_name_rest(self, s: str, target: str) -> str: ...
+    @overload
+    def pprint_setters(
+        self, prop: None = ..., leadingspace: int = ...
+    ) -> list[str]: ...
+    @overload
+    def pprint_setters(self, prop: str, leadingspace: int = ...) -> str: ...
+    @overload
+    def pprint_setters_rest(
+        self, prop: None = ..., leadingspace: int = ...
+    ) -> list[str]: ...
+    @overload
+    def pprint_setters_rest(self, prop: str, leadingspace: int = ...) -> str: ...
+    def properties(self) -> dict[str, Any]: ...
+    def pprint_getters(self) -> list[str]: ...
+
+def getp(obj: Artist, property: str | None = ...) -> Any: ...
+
+get = getp
+
+def setp(obj: Artist, *args, file: TextIO | None = ..., **kwargs) -> list[Any] | None: ...
+def kwdoc(artist: Artist | type[Artist] | Iterable[Artist | type[Artist]]) -> str: ...

infer_4_37_2/lib/python3.10/site-packages/matplotlib/backend_tools.py

@@ -0,0 +1,998 @@
+"""
+Abstract base classes define the primitives for Tools.
+These tools are used by `matplotlib.backend_managers.ToolManager`
+
+:class:`ToolBase`
+    Simple stateless tool
+
+:class:`ToolToggleBase`
+    Tool that has two states, only one Toggle tool can be
+    active at any given time for the same
+    `matplotlib.backend_managers.ToolManager`
+"""
+
+import enum
+import functools
+import re
+import time
+from types import SimpleNamespace
+import uuid
+from weakref import WeakKeyDictionary
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib._pylab_helpers import Gcf
+from matplotlib import _api, cbook
+
+
+class Cursors(enum.IntEnum):  # Must subclass int for the macOS backend.
+    """Backend-independent cursor types."""
+    POINTER = enum.auto()
+    HAND = enum.auto()
+    SELECT_REGION = enum.auto()
+    MOVE = enum.auto()
+    WAIT = enum.auto()
+    RESIZE_HORIZONTAL = enum.auto()
+    RESIZE_VERTICAL = enum.auto()
+cursors = Cursors  # Backcompat.
+
+
+# _tool_registry, _register_tool_class, and _find_tool_class implement a
+# mechanism through which ToolManager.add_tool can determine whether a subclass
+# of the requested tool class has been registered (either for the current
+# canvas class or for a parent class), in which case that tool subclass will be
+# instantiated instead.  This is the mechanism used e.g. to allow different
+# GUI backends to implement different specializations for ConfigureSubplots.
+
+
+_tool_registry = set()
+
+
+def _register_tool_class(canvas_cls, tool_cls=None):
+    """Decorator registering *tool_cls* as a tool class for *canvas_cls*."""
+    if tool_cls is None:
+        return functools.partial(_register_tool_class, canvas_cls)
+    _tool_registry.add((canvas_cls, tool_cls))
+    return tool_cls
+
+
+def _find_tool_class(canvas_cls, tool_cls):
+    """Find a subclass of *tool_cls* registered for *canvas_cls*."""
+    for canvas_parent in canvas_cls.__mro__:
+        for tool_child in _api.recursive_subclasses(tool_cls):
+            if (canvas_parent, tool_child) in _tool_registry:
+                return tool_child
+    return tool_cls
+
+
+# Views positions tool
+_views_positions = 'viewpos'
+
+
+class ToolBase:
+    """
+    Base tool class.
+
+    A base tool, only implements `trigger` method or no method at all.
+    The tool is instantiated by `matplotlib.backend_managers.ToolManager`.
+    """
+
+    default_keymap = None
+    """
+    Keymap to associate with this tool.
+
+    ``list[str]``: List of keys that will trigger this tool when a keypress
+    event is emitted on ``self.figure.canvas``.  Note that this attribute is
+    looked up on the instance, and can therefore be a property (this is used
+    e.g. by the built-in tools to load the rcParams at instantiation time).
+    """
+
+    description = None
+    """
+    Description of the Tool.
+
+    `str`: Tooltip used if the Tool is included in a Toolbar.
+    """
+
+    image = None
+    """
+    Icon filename.
+
+    ``str | None``: Filename of the Toolbar icon; either absolute, or relative to the
+    directory containing the Python source file where the ``Tool.image`` class attribute
+    is defined (in the latter case, this cannot be defined as an instance attribute).
+    In either case, the extension is optional; leaving it off lets individual backends
+    select the icon format they prefer.  If None, the *name* is used as a label in the
+    toolbar button.
+    """
+
+    def __init__(self, toolmanager, name):
+        self._name = name
+        self._toolmanager = toolmanager
+        self._figure = None
+
+    name = property(
+        lambda self: self._name,
+        doc="The tool id (str, must be unique among tools of a tool manager).")
+    toolmanager = property(
+        lambda self: self._toolmanager,
+        doc="The `.ToolManager` that controls this tool.")
+    canvas = property(
+        lambda self: self._figure.canvas if self._figure is not None else None,
+        doc="The canvas of the figure affected by this tool, or None.")
+
+    def set_figure(self, figure):
+        self._figure = figure
+
+    figure = property(
+        lambda self: self._figure,
+        # The setter must explicitly call self.set_figure so that subclasses can
+        # meaningfully override it.
+        lambda self, figure: self.set_figure(figure),
+        doc="The Figure affected by this tool, or None.")
+
+    def _make_classic_style_pseudo_toolbar(self):
+        """
+        Return a placeholder object with a single `canvas` attribute.
+
+        This is useful to reuse the implementations of tools already provided
+        by the classic Toolbars.
+        """
+        return SimpleNamespace(canvas=self.canvas)
+
+    def trigger(self, sender, event, data=None):
+        """
+        Called when this tool gets used.
+
+        This method is called by `.ToolManager.trigger_tool`.
+
+        Parameters
+        ----------
+        event : `.Event`
+            The canvas event that caused this tool to be called.
+        sender : object
+            Object that requested the tool to be triggered.
+        data : object
+            Extra data.
+        """
+        pass
+
+
+class ToolToggleBase(ToolBase):
+    """
+    Toggleable tool.
+
+    Every time it is triggered, it switches between enable and disable.
+
+    Parameters
+    ----------
+    ``*args``
+        Variable length argument to be used by the Tool.
+    ``**kwargs``
+        `toggled` if present and True, sets the initial state of the Tool
+        Arbitrary keyword arguments to be consumed by the Tool
+    """
+
+    radio_group = None
+    """
+    Attribute to group 'radio' like tools (mutually exclusive).
+
+    `str` that identifies the group or **None** if not belonging to a group.
+    """
+
+    cursor = None
+    """Cursor to use when the tool is active."""
+
+    default_toggled = False
+    """Default of toggled state."""
+
+    def __init__(self, *args, **kwargs):
+        self._toggled = kwargs.pop('toggled', self.default_toggled)
+        super().__init__(*args, **kwargs)
+
+    def trigger(self, sender, event, data=None):
+        """Calls `enable` or `disable` based on `toggled` value."""
+        if self._toggled:
+            self.disable(event)
+        else:
+            self.enable(event)
+        self._toggled = not self._toggled
+
+    def enable(self, event=None):
+        """
+        Enable the toggle tool.
+
+        `trigger` calls this method when `toggled` is False.
+        """
+        pass
+
+    def disable(self, event=None):
+        """
+        Disable the toggle tool.
+
+        `trigger` call this method when `toggled` is True.
+
+        This can happen in different circumstances.
+
+        * Click on the toolbar tool button.
+        * Call to `matplotlib.backend_managers.ToolManager.trigger_tool`.
+        * Another `ToolToggleBase` derived tool is triggered
+          (from the same `.ToolManager`).
+        """
+        pass
+
+    @property
+    def toggled(self):
+        """State of the toggled tool."""
+        return self._toggled
+
+    def set_figure(self, figure):
+        toggled = self.toggled
+        if toggled:
+            if self.figure:
+                self.trigger(self, None)
+            else:
+                # if no figure the internal state is not changed
+                # we change it here so next call to trigger will change it back
+                self._toggled = False
+        super().set_figure(figure)
+        if toggled:
+            if figure:
+                self.trigger(self, None)
+            else:
+                # if there is no figure, trigger won't change the internal
+                # state we change it back
+                self._toggled = True
+
+
+class ToolSetCursor(ToolBase):
+    """
+    Change to the current cursor while inaxes.
+
+    This tool, keeps track of all `ToolToggleBase` derived tools, and updates
+    the cursor when a tool gets triggered.
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._id_drag = None
+        self._current_tool = None
+        self._default_cursor = cursors.POINTER
+        self._last_cursor = self._default_cursor
+        self.toolmanager.toolmanager_connect('tool_added_event',
+                                             self._add_tool_cbk)
+        for tool in self.toolmanager.tools.values():  # process current tools
+            self._add_tool_cbk(mpl.backend_managers.ToolEvent(
+                'tool_added_event', self.toolmanager, tool))
+
+    def set_figure(self, figure):
+        if self._id_drag:
+            self.canvas.mpl_disconnect(self._id_drag)
+        super().set_figure(figure)
+        if figure:
+            self._id_drag = self.canvas.mpl_connect(
+                'motion_notify_event', self._set_cursor_cbk)
+
+    def _add_tool_cbk(self, event):
+        """Process every newly added tool."""
+        if getattr(event.tool, 'cursor', None) is not None:
+            self.toolmanager.toolmanager_connect(
+                f'tool_trigger_{event.tool.name}', self._tool_trigger_cbk)
+
+    def _tool_trigger_cbk(self, event):
+        self._current_tool = event.tool if event.tool.toggled else None
+        self._set_cursor_cbk(event.canvasevent)
+
+    def _set_cursor_cbk(self, event):
+        if not event or not self.canvas:
+            return
+        if (self._current_tool and getattr(event, "inaxes", None)
+                and event.inaxes.get_navigate()):
+            if self._last_cursor != self._current_tool.cursor:
+                self.canvas.set_cursor(self._current_tool.cursor)
+                self._last_cursor = self._current_tool.cursor
+        elif self._last_cursor != self._default_cursor:
+            self.canvas.set_cursor(self._default_cursor)
+            self._last_cursor = self._default_cursor
+
+
+class ToolCursorPosition(ToolBase):
+    """
+    Send message with the current pointer position.
+
+    This tool runs in the background reporting the position of the cursor.
+    """
+    def __init__(self, *args, **kwargs):
+        self._id_drag = None
+        super().__init__(*args, **kwargs)
+
+    def set_figure(self, figure):
+        if self._id_drag:
+            self.canvas.mpl_disconnect(self._id_drag)
+        super().set_figure(figure)
+        if figure:
+            self._id_drag = self.canvas.mpl_connect(
+                'motion_notify_event', self.send_message)
+
+    def send_message(self, event):
+        """Call `matplotlib.backend_managers.ToolManager.message_event`."""
+        if self.toolmanager.messagelock.locked():
+            return
+
+        from matplotlib.backend_bases import NavigationToolbar2
+        message = NavigationToolbar2._mouse_event_to_message(event)
+        self.toolmanager.message_event(message, self)
+
+
+class RubberbandBase(ToolBase):
+    """Draw and remove a rubberband."""
+    def trigger(self, sender, event, data=None):
+        """Call `draw_rubberband` or `remove_rubberband` based on data."""
+        if not self.figure.canvas.widgetlock.available(sender):
+            return
+        if data is not None:
+            self.draw_rubberband(*data)
+        else:
+            self.remove_rubberband()
+
+    def draw_rubberband(self, *data):
+        """
+        Draw rubberband.
+
+        This method must get implemented per backend.
+        """
+        raise NotImplementedError
+
+    def remove_rubberband(self):
+        """
+        Remove rubberband.
+
+        This method should get implemented per backend.
+        """
+        pass
+
+
+class ToolQuit(ToolBase):
+    """Tool to call the figure manager destroy method."""
+
+    description = 'Quit the figure'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.quit'])
+
+    def trigger(self, sender, event, data=None):
+        Gcf.destroy_fig(self.figure)
+
+
+class ToolQuitAll(ToolBase):
+    """Tool to call the figure manager destroy method."""
+
+    description = 'Quit all figures'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.quit_all'])
+
+    def trigger(self, sender, event, data=None):
+        Gcf.destroy_all()
+
+
+class ToolGrid(ToolBase):
+    """Tool to toggle the major grids of the figure."""
+
+    description = 'Toggle major grids'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.grid'])
+
+    def trigger(self, sender, event, data=None):
+        sentinel = str(uuid.uuid4())
+        # Trigger grid switching by temporarily setting :rc:`keymap.grid`
+        # to a unique key and sending an appropriate event.
+        with (cbook._setattr_cm(event, key=sentinel),
+              mpl.rc_context({'keymap.grid': sentinel})):
+            mpl.backend_bases.key_press_handler(event, self.figure.canvas)
+
+
+class ToolMinorGrid(ToolBase):
+    """Tool to toggle the major and minor grids of the figure."""
+
+    description = 'Toggle major and minor grids'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.grid_minor'])
+
+    def trigger(self, sender, event, data=None):
+        sentinel = str(uuid.uuid4())
+        # Trigger grid switching by temporarily setting :rc:`keymap.grid_minor`
+        # to a unique key and sending an appropriate event.
+        with (cbook._setattr_cm(event, key=sentinel),
+              mpl.rc_context({'keymap.grid_minor': sentinel})):
+            mpl.backend_bases.key_press_handler(event, self.figure.canvas)
+
+
+class ToolFullScreen(ToolBase):
+    """Tool to toggle full screen."""
+
+    description = 'Toggle fullscreen mode'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.fullscreen'])
+
+    def trigger(self, sender, event, data=None):
+        self.figure.canvas.manager.full_screen_toggle()
+
+
+class AxisScaleBase(ToolToggleBase):
+    """Base Tool to toggle between linear and logarithmic."""
+
+    def trigger(self, sender, event, data=None):
+        if event.inaxes is None:
+            return
+        super().trigger(sender, event, data)
+
+    def enable(self, event=None):
+        self.set_scale(event.inaxes, 'log')
+        self.figure.canvas.draw_idle()
+
+    def disable(self, event=None):
+        self.set_scale(event.inaxes, 'linear')
+        self.figure.canvas.draw_idle()
+
+
+class ToolYScale(AxisScaleBase):
+    """Tool to toggle between linear and logarithmic scales on the Y axis."""
+
+    description = 'Toggle scale Y axis'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.yscale'])
+
+    def set_scale(self, ax, scale):
+        ax.set_yscale(scale)
+
+
+class ToolXScale(AxisScaleBase):
+    """Tool to toggle between linear and logarithmic scales on the X axis."""
+
+    description = 'Toggle scale X axis'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.xscale'])
+
+    def set_scale(self, ax, scale):
+        ax.set_xscale(scale)
+
+
+class ToolViewsPositions(ToolBase):
+    """
+    Auxiliary Tool to handle changes in views and positions.
+
+    Runs in the background and should get used by all the tools that
+    need to access the figure's history of views and positions, e.g.
+
+    * `ToolZoom`
+    * `ToolPan`
+    * `ToolHome`
+    * `ToolBack`
+    * `ToolForward`
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.views = WeakKeyDictionary()
+        self.positions = WeakKeyDictionary()
+        self.home_views = WeakKeyDictionary()
+        super().__init__(*args, **kwargs)
+
+    def add_figure(self, figure):
+        """Add the current figure to the stack of views and positions."""
+
+        if figure not in self.views:
+            self.views[figure] = cbook._Stack()
+            self.positions[figure] = cbook._Stack()
+            self.home_views[figure] = WeakKeyDictionary()
+            # Define Home
+            self.push_current(figure)
+            # Make sure we add a home view for new Axes as they're added
+            figure.add_axobserver(lambda fig: self.update_home_views(fig))
+
+    def clear(self, figure):
+        """Reset the Axes stack."""
+        if figure in self.views:
+            self.views[figure].clear()
+            self.positions[figure].clear()
+            self.home_views[figure].clear()
+            self.update_home_views()
+
+    def update_view(self):
+        """
+        Update the view limits and position for each Axes from the current
+        stack position. If any Axes are present in the figure that aren't in
+        the current stack position, use the home view limits for those Axes and
+        don't update *any* positions.
+        """
+
+        views = self.views[self.figure]()
+        if views is None:
+            return
+        pos = self.positions[self.figure]()
+        if pos is None:
+            return
+        home_views = self.home_views[self.figure]
+        all_axes = self.figure.get_axes()
+        for a in all_axes:
+            if a in views:
+                cur_view = views[a]
+            else:
+                cur_view = home_views[a]
+            a._set_view(cur_view)
+
+        if set(all_axes).issubset(pos):
+            for a in all_axes:
+                # Restore both the original and modified positions
+                a._set_position(pos[a][0], 'original')
+                a._set_position(pos[a][1], 'active')
+
+        self.figure.canvas.draw_idle()
+
+    def push_current(self, figure=None):
+        """
+        Push the current view limits and position onto their respective stacks.
+        """
+        if not figure:
+            figure = self.figure
+        views = WeakKeyDictionary()
+        pos = WeakKeyDictionary()
+        for a in figure.get_axes():
+            views[a] = a._get_view()
+            pos[a] = self._axes_pos(a)
+        self.views[figure].push(views)
+        self.positions[figure].push(pos)
+
+    def _axes_pos(self, ax):
+        """
+        Return the original and modified positions for the specified Axes.
+
+        Parameters
+        ----------
+        ax : matplotlib.axes.Axes
+            The `.Axes` to get the positions for.
+
+        Returns
+        -------
+        original_position, modified_position
+            A tuple of the original and modified positions.
+        """
+
+        return (ax.get_position(True).frozen(),
+                ax.get_position().frozen())
+
+    def update_home_views(self, figure=None):
+        """
+        Make sure that ``self.home_views`` has an entry for all Axes present
+        in the figure.
+        """
+
+        if not figure:
+            figure = self.figure
+        for a in figure.get_axes():
+            if a not in self.home_views[figure]:
+                self.home_views[figure][a] = a._get_view()
+
+    def home(self):
+        """Recall the first view and position from the stack."""
+        self.views[self.figure].home()
+        self.positions[self.figure].home()
+
+    def back(self):
+        """Back one step in the stack of views and positions."""
+        self.views[self.figure].back()
+        self.positions[self.figure].back()
+
+    def forward(self):
+        """Forward one step in the stack of views and positions."""
+        self.views[self.figure].forward()
+        self.positions[self.figure].forward()
+
+
+class ViewsPositionsBase(ToolBase):
+    """Base class for `ToolHome`, `ToolBack` and `ToolForward`."""
+
+    _on_trigger = None
+
+    def trigger(self, sender, event, data=None):
+        self.toolmanager.get_tool(_views_positions).add_figure(self.figure)
+        getattr(self.toolmanager.get_tool(_views_positions),
+                self._on_trigger)()
+        self.toolmanager.get_tool(_views_positions).update_view()
+
+
+class ToolHome(ViewsPositionsBase):
+    """Restore the original view limits."""
+
+    description = 'Reset original view'
+    image = 'mpl-data/images/home'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.home'])
+    _on_trigger = 'home'
+
+
+class ToolBack(ViewsPositionsBase):
+    """Move back up the view limits stack."""
+
+    description = 'Back to previous view'
+    image = 'mpl-data/images/back'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.back'])
+    _on_trigger = 'back'
+
+
+class ToolForward(ViewsPositionsBase):
+    """Move forward in the view lim stack."""
+
+    description = 'Forward to next view'
+    image = 'mpl-data/images/forward'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.forward'])
+    _on_trigger = 'forward'
+
+
+class ConfigureSubplotsBase(ToolBase):
+    """Base tool for the configuration of subplots."""
+
+    description = 'Configure subplots'
+    image = 'mpl-data/images/subplots'
+
+
+class SaveFigureBase(ToolBase):
+    """Base tool for figure saving."""
+
+    description = 'Save the figure'
+    image = 'mpl-data/images/filesave'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.save'])
+
+
+class ZoomPanBase(ToolToggleBase):
+    """Base class for `ToolZoom` and `ToolPan`."""
+    def __init__(self, *args):
+        super().__init__(*args)
+        self._button_pressed = None
+        self._xypress = None
+        self._idPress = None
+        self._idRelease = None
+        self._idScroll = None
+        self.base_scale = 2.
+        self.scrollthresh = .5  # .5 second scroll threshold
+        self.lastscroll = time.time()-self.scrollthresh
+
+    def enable(self, event=None):
+        """Connect press/release events and lock the canvas."""
+        self.figure.canvas.widgetlock(self)
+        self._idPress = self.figure.canvas.mpl_connect(
+            'button_press_event', self._press)
+        self._idRelease = self.figure.canvas.mpl_connect(
+            'button_release_event', self._release)
+        self._idScroll = self.figure.canvas.mpl_connect(
+            'scroll_event', self.scroll_zoom)
+
+    def disable(self, event=None):
+        """Release the canvas and disconnect press/release events."""
+        self._cancel_action()
+        self.figure.canvas.widgetlock.release(self)
+        self.figure.canvas.mpl_disconnect(self._idPress)
+        self.figure.canvas.mpl_disconnect(self._idRelease)
+        self.figure.canvas.mpl_disconnect(self._idScroll)
+
+    def trigger(self, sender, event, data=None):
+        self.toolmanager.get_tool(_views_positions).add_figure(self.figure)
+        super().trigger(sender, event, data)
+        new_navigate_mode = self.name.upper() if self.toggled else None
+        for ax in self.figure.axes:
+            ax.set_navigate_mode(new_navigate_mode)
+
+    def scroll_zoom(self, event):
+        # https://gist.github.com/tacaswell/3144287
+        if event.inaxes is None:
+            return
+
+        if event.button == 'up':
+            # deal with zoom in
+            scl = self.base_scale
+        elif event.button == 'down':
+            # deal with zoom out
+            scl = 1/self.base_scale
+        else:
+            # deal with something that should never happen
+            scl = 1
+
+        ax = event.inaxes
+        ax._set_view_from_bbox([event.x, event.y, scl])
+
+        # If last scroll was done within the timing threshold, delete the
+        # previous view
+        if (time.time()-self.lastscroll) < self.scrollthresh:
+            self.toolmanager.get_tool(_views_positions).back()
+
+        self.figure.canvas.draw_idle()  # force re-draw
+
+        self.lastscroll = time.time()
+        self.toolmanager.get_tool(_views_positions).push_current()
+
+
+class ToolZoom(ZoomPanBase):
+    """A Tool for zooming using a rectangle selector."""
+
+    description = 'Zoom to rectangle'
+    image = 'mpl-data/images/zoom_to_rect'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.zoom'])
+    cursor = cursors.SELECT_REGION
+    radio_group = 'default'
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self._ids_zoom = []
+
+    def _cancel_action(self):
+        for zoom_id in self._ids_zoom:
+            self.figure.canvas.mpl_disconnect(zoom_id)
+        self.toolmanager.trigger_tool('rubberband', self)
+        self.figure.canvas.draw_idle()
+        self._xypress = None
+        self._button_pressed = None
+        self._ids_zoom = []
+        return
+
+    def _press(self, event):
+        """Callback for mouse button presses in zoom-to-rectangle mode."""
+
+        # If we're already in the middle of a zoom, pressing another
+        # button works to "cancel"
+        if self._ids_zoom:
+            self._cancel_action()
+
+        if event.button == 1:
+            self._button_pressed = 1
+        elif event.button == 3:
+            self._button_pressed = 3
+        else:
+            self._cancel_action()
+            return
+
+        x, y = event.x, event.y
+
+        self._xypress = []
+        for i, a in enumerate(self.figure.get_axes()):
+            if (x is not None and y is not None and a.in_axes(event) and
+                    a.get_navigate() and a.can_zoom()):
+                self._xypress.append((x, y, a, i, a._get_view()))
+
+        id1 = self.figure.canvas.mpl_connect(
+            'motion_notify_event', self._mouse_move)
+        id2 = self.figure.canvas.mpl_connect(
+            'key_press_event', self._switch_on_zoom_mode)
+        id3 = self.figure.canvas.mpl_connect(
+            'key_release_event', self._switch_off_zoom_mode)
+
+        self._ids_zoom = id1, id2, id3
+        self._zoom_mode = event.key
+
+    def _switch_on_zoom_mode(self, event):
+        self._zoom_mode = event.key
+        self._mouse_move(event)
+
+    def _switch_off_zoom_mode(self, event):
+        self._zoom_mode = None
+        self._mouse_move(event)
+
+    def _mouse_move(self, event):
+        """Callback for mouse moves in zoom-to-rectangle mode."""
+
+        if self._xypress:
+            x, y = event.x, event.y
+            lastx, lasty, a, ind, view = self._xypress[0]
+            (x1, y1), (x2, y2) = np.clip(
+                [[lastx, lasty], [x, y]], a.bbox.min, a.bbox.max)
+            if self._zoom_mode == "x":
+                y1, y2 = a.bbox.intervaly
+            elif self._zoom_mode == "y":
+                x1, x2 = a.bbox.intervalx
+            self.toolmanager.trigger_tool(
+                'rubberband', self, data=(x1, y1, x2, y2))
+
+    def _release(self, event):
+        """Callback for mouse button releases in zoom-to-rectangle mode."""
+
+        for zoom_id in self._ids_zoom:
+            self.figure.canvas.mpl_disconnect(zoom_id)
+        self._ids_zoom = []
+
+        if not self._xypress:
+            self._cancel_action()
+            return
+
+        done_ax = []
+
+        for cur_xypress in self._xypress:
+            x, y = event.x, event.y
+            lastx, lasty, a, _ind, view = cur_xypress
+            # ignore singular clicks - 5 pixels is a threshold
+            if abs(x - lastx) < 5 or abs(y - lasty) < 5:
+                self._cancel_action()
+                return
+
+            # detect twinx, twiny Axes and avoid double zooming
+            twinx = any(a.get_shared_x_axes().joined(a, a1) for a1 in done_ax)
+            twiny = any(a.get_shared_y_axes().joined(a, a1) for a1 in done_ax)
+            done_ax.append(a)
+
+            if self._button_pressed == 1:
+                direction = 'in'
+            elif self._button_pressed == 3:
+                direction = 'out'
+            else:
+                continue
+
+            a._set_view_from_bbox((lastx, lasty, x, y), direction,
+                                  self._zoom_mode, twinx, twiny)
+
+        self._zoom_mode = None
+        self.toolmanager.get_tool(_views_positions).push_current()
+        self._cancel_action()
+
+
+class ToolPan(ZoomPanBase):
+    """Pan Axes with left mouse, zoom with right."""
+
+    default_keymap = property(lambda self: mpl.rcParams['keymap.pan'])
+    description = 'Pan axes with left mouse, zoom with right'
+    image = 'mpl-data/images/move'
+    cursor = cursors.MOVE
+    radio_group = 'default'
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self._id_drag = None
+
+    def _cancel_action(self):
+        self._button_pressed = None
+        self._xypress = []
+        self.figure.canvas.mpl_disconnect(self._id_drag)
+        self.toolmanager.messagelock.release(self)
+        self.figure.canvas.draw_idle()
+
+    def _press(self, event):
+        if event.button == 1:
+            self._button_pressed = 1
+        elif event.button == 3:
+            self._button_pressed = 3
+        else:
+            self._cancel_action()
+            return
+
+        x, y = event.x, event.y
+
+        self._xypress = []
+        for i, a in enumerate(self.figure.get_axes()):
+            if (x is not None and y is not None and a.in_axes(event) and
+                    a.get_navigate() and a.can_pan()):
+                a.start_pan(x, y, event.button)
+                self._xypress.append((a, i))
+                self.toolmanager.messagelock(self)
+                self._id_drag = self.figure.canvas.mpl_connect(
+                    'motion_notify_event', self._mouse_move)
+
+    def _release(self, event):
+        if self._button_pressed is None:
+            self._cancel_action()
+            return
+
+        self.figure.canvas.mpl_disconnect(self._id_drag)
+        self.toolmanager.messagelock.release(self)
+
+        for a, _ind in self._xypress:
+            a.end_pan()
+        if not self._xypress:
+            self._cancel_action()
+            return
+
+        self.toolmanager.get_tool(_views_positions).push_current()
+        self._cancel_action()
+
+    def _mouse_move(self, event):
+        for a, _ind in self._xypress:
+            # safer to use the recorded button at the _press than current
+            # button: # multiple button can get pressed during motion...
+            a.drag_pan(self._button_pressed, event.key, event.x, event.y)
+        self.toolmanager.canvas.draw_idle()
+
+
+class ToolHelpBase(ToolBase):
+    description = 'Print tool list, shortcuts and description'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.help'])
+    image = 'mpl-data/images/help'
+
+    @staticmethod
+    def format_shortcut(key_sequence):
+        """
+        Convert a shortcut string from the notation used in rc config to the
+        standard notation for displaying shortcuts, e.g. 'ctrl+a' -> 'Ctrl+A'.
+        """
+        return (key_sequence if len(key_sequence) == 1 else
+                re.sub(r"\+[A-Z]", r"+Shift\g<0>", key_sequence).title())
+
+    def _format_tool_keymap(self, name):
+        keymaps = self.toolmanager.get_tool_keymap(name)
+        return ", ".join(self.format_shortcut(keymap) for keymap in keymaps)
+
+    def _get_help_entries(self):
+        return [(name, self._format_tool_keymap(name), tool.description)
+                for name, tool in sorted(self.toolmanager.tools.items())
+                if tool.description]
+
+    def _get_help_text(self):
+        entries = self._get_help_entries()
+        entries = ["{}: {}\n\t{}".format(*entry) for entry in entries]
+        return "\n".join(entries)
+
+    def _get_help_html(self):
+        fmt = "<tr><td>{}</td><td>{}</td><td>{}</td></tr>"
+        rows = [fmt.format(
+            "<b>Action</b>", "<b>Shortcuts</b>", "<b>Description</b>")]
+        rows += [fmt.format(*row) for row in self._get_help_entries()]
+        return ("<style>td {padding: 0px 4px}</style>"
+                "<table><thead>" + rows[0] + "</thead>"
+                "<tbody>".join(rows[1:]) + "</tbody></table>")
+
+
+class ToolCopyToClipboardBase(ToolBase):
+    """Tool to copy the figure to the clipboard."""
+
+    description = 'Copy the canvas figure to clipboard'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.copy'])
+
+    def trigger(self, *args, **kwargs):
+        message = "Copy tool is not available"
+        self.toolmanager.message_event(message, self)
+
+
+default_tools = {'home': ToolHome, 'back': ToolBack, 'forward': ToolForward,
+                 'zoom': ToolZoom, 'pan': ToolPan,
+                 'subplots': ConfigureSubplotsBase,
+                 'save': SaveFigureBase,
+                 'grid': ToolGrid,
+                 'grid_minor': ToolMinorGrid,
+                 'fullscreen': ToolFullScreen,
+                 'quit': ToolQuit,
+                 'quit_all': ToolQuitAll,
+                 'xscale': ToolXScale,
+                 'yscale': ToolYScale,
+                 'position': ToolCursorPosition,
+                 _views_positions: ToolViewsPositions,
+                 'cursor': ToolSetCursor,
+                 'rubberband': RubberbandBase,
+                 'help': ToolHelpBase,
+                 'copy': ToolCopyToClipboardBase,
+                 }
+
+default_toolbar_tools = [['navigation', ['home', 'back', 'forward']],
+                         ['zoompan', ['pan', 'zoom', 'subplots']],
+                         ['io', ['save', 'help']]]
+
+
+def add_tools_to_manager(toolmanager, tools=default_tools):
+    """
+    Add multiple tools to a `.ToolManager`.
+
+    Parameters
+    ----------
+    toolmanager : `.backend_managers.ToolManager`
+        Manager to which the tools are added.
+    tools : {str: class_like}, optional
+        The tools to add in a {name: tool} dict, see
+        `.backend_managers.ToolManager.add_tool` for more info.
+    """
+
+    for name, tool in tools.items():
+        toolmanager.add_tool(name, tool)
+
+
+def add_tools_to_container(container, tools=default_toolbar_tools):
+    """
+    Add multiple tools to the container.
+
+    Parameters
+    ----------
+    container : Container
+        `.backend_bases.ToolContainerBase` object that will get the tools
+        added.
+    tools : list, optional
+        List in the form ``[[group1, [tool1, tool2 ...]], [group2, [...]]]``
+        where the tools ``[tool1, tool2, ...]`` will display in group1.
+        See `.backend_bases.ToolContainerBase.add_tool` for details.
+    """
+
+    for group, grouptools in tools:
+        for position, tool in enumerate(grouptools):
+            container.add_tool(tool, group, position)

infer_4_37_2/lib/python3.10/site-packages/matplotlib/bezier.py

@@ -0,0 +1,602 @@
+"""
+A module providing some utility functions regarding Bézier path manipulation.
+"""
+
+from functools import lru_cache
+import math
+import warnings
+
+import numpy as np
+
+from matplotlib import _api
+
+
+# same algorithm as 3.8's math.comb
+@np.vectorize
+@lru_cache(maxsize=128)
+def _comb(n, k):
+    if k > n:
+        return 0
+    k = min(k, n - k)
+    i = np.arange(1, k + 1)
+    return np.prod((n + 1 - i)/i).astype(int)
+
+
+class NonIntersectingPathException(ValueError):
+    pass
+
+
+# some functions
+
+
+def get_intersection(cx1, cy1, cos_t1, sin_t1,
+                     cx2, cy2, cos_t2, sin_t2):
+    """
+    Return the intersection between the line through (*cx1*, *cy1*) at angle
+    *t1* and the line through (*cx2*, *cy2*) at angle *t2*.
+    """
+
+    # line1 => sin_t1 * (x - cx1) - cos_t1 * (y - cy1) = 0.
+    # line1 => sin_t1 * x + cos_t1 * y = sin_t1*cx1 - cos_t1*cy1
+
+    line1_rhs = sin_t1 * cx1 - cos_t1 * cy1
+    line2_rhs = sin_t2 * cx2 - cos_t2 * cy2
+
+    # rhs matrix
+    a, b = sin_t1, -cos_t1
+    c, d = sin_t2, -cos_t2
+
+    ad_bc = a * d - b * c
+    if abs(ad_bc) < 1e-12:
+        raise ValueError("Given lines do not intersect. Please verify that "
+                         "the angles are not equal or differ by 180 degrees.")
+
+    # rhs_inverse
+    a_, b_ = d, -b
+    c_, d_ = -c, a
+    a_, b_, c_, d_ = (k / ad_bc for k in [a_, b_, c_, d_])
+
+    x = a_ * line1_rhs + b_ * line2_rhs
+    y = c_ * line1_rhs + d_ * line2_rhs
+
+    return x, y
+
+
+def get_normal_points(cx, cy, cos_t, sin_t, length):
+    """
+    For a line passing through (*cx*, *cy*) and having an angle *t*, return
+    locations of the two points located along its perpendicular line at the
+    distance of *length*.
+    """
+
+    if length == 0.:
+        return cx, cy, cx, cy
+
+    cos_t1, sin_t1 = sin_t, -cos_t
+    cos_t2, sin_t2 = -sin_t, cos_t
+
+    x1, y1 = length * cos_t1 + cx, length * sin_t1 + cy
+    x2, y2 = length * cos_t2 + cx, length * sin_t2 + cy
+
+    return x1, y1, x2, y2
+
+
+# BEZIER routines
+
+# subdividing bezier curve
+# http://www.cs.mtu.edu/~shene/COURSES/cs3621/NOTES/spline/Bezier/bezier-sub.html
+
+
+def _de_casteljau1(beta, t):
+    next_beta = beta[:-1] * (1 - t) + beta[1:] * t
+    return next_beta
+
+
+def split_de_casteljau(beta, t):
+    """
+    Split a Bézier segment defined by its control points *beta* into two
+    separate segments divided at *t* and return their control points.
+    """
+    beta = np.asarray(beta)
+    beta_list = [beta]
+    while True:
+        beta = _de_casteljau1(beta, t)
+        beta_list.append(beta)
+        if len(beta) == 1:
+            break
+    left_beta = [beta[0] for beta in beta_list]
+    right_beta = [beta[-1] for beta in reversed(beta_list)]
+
+    return left_beta, right_beta
+
+
+def find_bezier_t_intersecting_with_closedpath(
+        bezier_point_at_t, inside_closedpath, t0=0., t1=1., tolerance=0.01):
+    """
+    Find the intersection of the Bézier curve with a closed path.
+
+    The intersection point *t* is approximated by two parameters *t0*, *t1*
+    such that *t0* <= *t* <= *t1*.
+
+    Search starts from *t0* and *t1* and uses a simple bisecting algorithm
+    therefore one of the end points must be inside the path while the other
+    doesn't. The search stops when the distance of the points parametrized by
+    *t0* and *t1* gets smaller than the given *tolerance*.
+
+    Parameters
+    ----------
+    bezier_point_at_t : callable
+        A function returning x, y coordinates of the Bézier at parameter *t*.
+        It must have the signature::
+
+            bezier_point_at_t(t: float) -> tuple[float, float]
+
+    inside_closedpath : callable
+        A function returning True if a given point (x, y) is inside the
+        closed path. It must have the signature::
+
+            inside_closedpath(point: tuple[float, float]) -> bool
+
+    t0, t1 : float
+        Start parameters for the search.
+
+    tolerance : float
+        Maximal allowed distance between the final points.
+
+    Returns
+    -------
+    t0, t1 : float
+        The Bézier path parameters.
+    """
+    start = bezier_point_at_t(t0)
+    end = bezier_point_at_t(t1)
+
+    start_inside = inside_closedpath(start)
+    end_inside = inside_closedpath(end)
+
+    if start_inside == end_inside and start != end:
+        raise NonIntersectingPathException(
+            "Both points are on the same side of the closed path")
+
+    while True:
+
+        # return if the distance is smaller than the tolerance
+        if np.hypot(start[0] - end[0], start[1] - end[1]) < tolerance:
+            return t0, t1
+
+        # calculate the middle point
+        middle_t = 0.5 * (t0 + t1)
+        middle = bezier_point_at_t(middle_t)
+        middle_inside = inside_closedpath(middle)
+
+        if start_inside ^ middle_inside:
+            t1 = middle_t
+            if end == middle:
+                # Edge case where infinite loop is possible
+                # Caused by large numbers relative to tolerance
+                return t0, t1
+            end = middle
+        else:
+            t0 = middle_t
+            if start == middle:
+                # Edge case where infinite loop is possible
+                # Caused by large numbers relative to tolerance
+                return t0, t1
+            start = middle
+            start_inside = middle_inside
+
+
+class BezierSegment:
+    """
+    A d-dimensional Bézier segment.
+
+    Parameters
+    ----------
+    control_points : (N, d) array
+        Location of the *N* control points.
+    """
+
+    def __init__(self, control_points):
+        self._cpoints = np.asarray(control_points)
+        self._N, self._d = self._cpoints.shape
+        self._orders = np.arange(self._N)
+        coeff = [math.factorial(self._N - 1)
+                 // (math.factorial(i) * math.factorial(self._N - 1 - i))
+                 for i in range(self._N)]
+        self._px = (self._cpoints.T * coeff).T
+
+    def __call__(self, t):
+        """
+        Evaluate the Bézier curve at point(s) *t* in [0, 1].
+
+        Parameters
+        ----------
+        t : (k,) array-like
+            Points at which to evaluate the curve.
+
+        Returns
+        -------
+        (k, d) array
+            Value of the curve for each point in *t*.
+        """
+        t = np.asarray(t)
+        return (np.power.outer(1 - t, self._orders[::-1])
+                * np.power.outer(t, self._orders)) @ self._px
+
+    def point_at_t(self, t):
+        """
+        Evaluate the curve at a single point, returning a tuple of *d* floats.
+        """
+        return tuple(self(t))
+
+    @property
+    def control_points(self):
+        """The control points of the curve."""
+        return self._cpoints
+
+    @property
+    def dimension(self):
+        """The dimension of the curve."""
+        return self._d
+
+    @property
+    def degree(self):
+        """Degree of the polynomial. One less the number of control points."""
+        return self._N - 1
+
+    @property
+    def polynomial_coefficients(self):
+        r"""
+        The polynomial coefficients of the Bézier curve.
+
+        .. warning:: Follows opposite convention from `numpy.polyval`.
+
+        Returns
+        -------
+        (n+1, d) array
+            Coefficients after expanding in polynomial basis, where :math:`n`
+            is the degree of the Bézier curve and :math:`d` its dimension.
+            These are the numbers (:math:`C_j`) such that the curve can be
+            written :math:`\sum_{j=0}^n C_j t^j`.
+
+        Notes
+        -----
+        The coefficients are calculated as
+
+        .. math::
+
+            {n \choose j} \sum_{i=0}^j (-1)^{i+j} {j \choose i} P_i
+
+        where :math:`P_i` are the control points of the curve.
+        """
+        n = self.degree
+        # matplotlib uses n <= 4. overflow plausible starting around n = 15.
+        if n > 10:
+            warnings.warn("Polynomial coefficients formula unstable for high "
+                          "order Bezier curves!", RuntimeWarning)
+        P = self.control_points
+        j = np.arange(n+1)[:, None]
+        i = np.arange(n+1)[None, :]  # _comb is non-zero for i <= j
+        prefactor = (-1)**(i + j) * _comb(j, i)  # j on axis 0, i on axis 1
+        return _comb(n, j) * prefactor @ P  # j on axis 0, self.dimension on 1
+
+    def axis_aligned_extrema(self):
+        """
+        Return the dimension and location of the curve's interior extrema.
+
+        The extrema are the points along the curve where one of its partial
+        derivatives is zero.
+
+        Returns
+        -------
+        dims : array of int
+            Index :math:`i` of the partial derivative which is zero at each
+            interior extrema.
+        dzeros : array of float
+            Of same size as dims. The :math:`t` such that :math:`d/dx_i B(t) =
+            0`
+        """
+        n = self.degree
+        if n <= 1:
+            return np.array([]), np.array([])
+        Cj = self.polynomial_coefficients
+        dCj = np.arange(1, n+1)[:, None] * Cj[1:]
+        dims = []
+        roots = []
+        for i, pi in enumerate(dCj.T):
+            r = np.roots(pi[::-1])
+            roots.append(r)
+            dims.append(np.full_like(r, i))
+        roots = np.concatenate(roots)
+        dims = np.concatenate(dims)
+        in_range = np.isreal(roots) & (roots >= 0) & (roots <= 1)
+        return dims[in_range], np.real(roots)[in_range]
+
+
+def split_bezier_intersecting_with_closedpath(
+        bezier, inside_closedpath, tolerance=0.01):
+    """
+    Split a Bézier curve into two at the intersection with a closed path.
+
+    Parameters
+    ----------
+    bezier : (N, 2) array-like
+        Control points of the Bézier segment. See `.BezierSegment`.
+    inside_closedpath : callable
+        A function returning True if a given point (x, y) is inside the
+        closed path. See also `.find_bezier_t_intersecting_with_closedpath`.
+    tolerance : float
+        The tolerance for the intersection. See also
+        `.find_bezier_t_intersecting_with_closedpath`.
+
+    Returns
+    -------
+    left, right
+        Lists of control points for the two Bézier segments.
+    """
+
+    bz = BezierSegment(bezier)
+    bezier_point_at_t = bz.point_at_t
+
+    t0, t1 = find_bezier_t_intersecting_with_closedpath(
+        bezier_point_at_t, inside_closedpath, tolerance=tolerance)
+
+    _left, _right = split_de_casteljau(bezier, (t0 + t1) / 2.)
+    return _left, _right
+
+
+# matplotlib specific
+
+
+def split_path_inout(path, inside, tolerance=0.01, reorder_inout=False):
+    """
+    Divide a path into two segments at the point where ``inside(x, y)`` becomes
+    False.
+    """
+    from .path import Path
+    path_iter = path.iter_segments()
+
+    ctl_points, command = next(path_iter)
+    begin_inside = inside(ctl_points[-2:])  # true if begin point is inside
+
+    ctl_points_old = ctl_points
+
+    iold = 0
+    i = 1
+
+    for ctl_points, command in path_iter:
+        iold = i
+        i += len(ctl_points) // 2
+        if inside(ctl_points[-2:]) != begin_inside:
+            bezier_path = np.concatenate([ctl_points_old[-2:], ctl_points])
+            break
+        ctl_points_old = ctl_points
+    else:
+        raise ValueError("The path does not intersect with the patch")
+
+    bp = bezier_path.reshape((-1, 2))
+    left, right = split_bezier_intersecting_with_closedpath(
+        bp, inside, tolerance)
+    if len(left) == 2:
+        codes_left = [Path.LINETO]
+        codes_right = [Path.MOVETO, Path.LINETO]
+    elif len(left) == 3:
+        codes_left = [Path.CURVE3, Path.CURVE3]
+        codes_right = [Path.MOVETO, Path.CURVE3, Path.CURVE3]
+    elif len(left) == 4:
+        codes_left = [Path.CURVE4, Path.CURVE4, Path.CURVE4]
+        codes_right = [Path.MOVETO, Path.CURVE4, Path.CURVE4, Path.CURVE4]
+    else:
+        raise AssertionError("This should never be reached")
+
+    verts_left = left[1:]
+    verts_right = right[:]
+
+    if path.codes is None:
+        path_in = Path(np.concatenate([path.vertices[:i], verts_left]))
+        path_out = Path(np.concatenate([verts_right, path.vertices[i:]]))
+
+    else:
+        path_in = Path(np.concatenate([path.vertices[:iold], verts_left]),
+                       np.concatenate([path.codes[:iold], codes_left]))
+
+        path_out = Path(np.concatenate([verts_right, path.vertices[i:]]),
+                        np.concatenate([codes_right, path.codes[i:]]))
+
+    if reorder_inout and not begin_inside:
+        path_in, path_out = path_out, path_in
+
+    return path_in, path_out
+
+
+def inside_circle(cx, cy, r):
+    """
+    Return a function that checks whether a point is in a circle with center
+    (*cx*, *cy*) and radius *r*.
+
+    The returned function has the signature::
+
+        f(xy: tuple[float, float]) -> bool
+    """
+    r2 = r ** 2
+
+    def _f(xy):
+        x, y = xy
+        return (x - cx) ** 2 + (y - cy) ** 2 < r2
+    return _f
+
+
+# quadratic Bezier lines
+
+def get_cos_sin(x0, y0, x1, y1):
+    dx, dy = x1 - x0, y1 - y0
+    d = (dx * dx + dy * dy) ** .5
+    # Account for divide by zero
+    if d == 0:
+        return 0.0, 0.0
+    return dx / d, dy / d
+
+
+def check_if_parallel(dx1, dy1, dx2, dy2, tolerance=1.e-5):
+    """
+    Check if two lines are parallel.
+
+    Parameters
+    ----------
+    dx1, dy1, dx2, dy2 : float
+        The gradients *dy*/*dx* of the two lines.
+    tolerance : float
+        The angular tolerance in radians up to which the lines are considered
+        parallel.
+
+    Returns
+    -------
+    is_parallel
+        - 1 if two lines are parallel in same direction.
+        - -1 if two lines are parallel in opposite direction.
+        - False otherwise.
+    """
+    theta1 = np.arctan2(dx1, dy1)
+    theta2 = np.arctan2(dx2, dy2)
+    dtheta = abs(theta1 - theta2)
+    if dtheta < tolerance:
+        return 1
+    elif abs(dtheta - np.pi) < tolerance:
+        return -1
+    else:
+        return False
+
+
+def get_parallels(bezier2, width):
+    """
+    Given the quadratic Bézier control points *bezier2*, returns
+    control points of quadratic Bézier lines roughly parallel to given
+    one separated by *width*.
+    """
+
+    # The parallel Bezier lines are constructed by following ways.
+    #  c1 and c2 are control points representing the start and end of the
+    #  Bezier line.
+    #  cm is the middle point
+
+    c1x, c1y = bezier2[0]
+    cmx, cmy = bezier2[1]
+    c2x, c2y = bezier2[2]
+
+    parallel_test = check_if_parallel(c1x - cmx, c1y - cmy,
+                                      cmx - c2x, cmy - c2y)
+
+    if parallel_test == -1:
+        _api.warn_external(
+            "Lines do not intersect. A straight line is used instead.")
+        cos_t1, sin_t1 = get_cos_sin(c1x, c1y, c2x, c2y)
+        cos_t2, sin_t2 = cos_t1, sin_t1
+    else:
+        # t1 and t2 is the angle between c1 and cm, cm, c2.  They are
+        # also an angle of the tangential line of the path at c1 and c2
+        cos_t1, sin_t1 = get_cos_sin(c1x, c1y, cmx, cmy)
+        cos_t2, sin_t2 = get_cos_sin(cmx, cmy, c2x, c2y)
+
+    # find c1_left, c1_right which are located along the lines
+    # through c1 and perpendicular to the tangential lines of the
+    # Bezier path at a distance of width. Same thing for c2_left and
+    # c2_right with respect to c2.
+    c1x_left, c1y_left, c1x_right, c1y_right = (
+        get_normal_points(c1x, c1y, cos_t1, sin_t1, width)
+    )
+    c2x_left, c2y_left, c2x_right, c2y_right = (
+        get_normal_points(c2x, c2y, cos_t2, sin_t2, width)
+    )
+
+    # find cm_left which is the intersecting point of a line through
+    # c1_left with angle t1 and a line through c2_left with angle
+    # t2. Same with cm_right.
+    try:
+        cmx_left, cmy_left = get_intersection(c1x_left, c1y_left, cos_t1,
+                                              sin_t1, c2x_left, c2y_left,
+                                              cos_t2, sin_t2)
+        cmx_right, cmy_right = get_intersection(c1x_right, c1y_right, cos_t1,
+                                                sin_t1, c2x_right, c2y_right,
+                                                cos_t2, sin_t2)
+    except ValueError:
+        # Special case straight lines, i.e., angle between two lines is
+        # less than the threshold used by get_intersection (we don't use
+        # check_if_parallel as the threshold is not the same).
+        cmx_left, cmy_left = (
+            0.5 * (c1x_left + c2x_left), 0.5 * (c1y_left + c2y_left)
+        )
+        cmx_right, cmy_right = (
+            0.5 * (c1x_right + c2x_right), 0.5 * (c1y_right + c2y_right)
+        )
+
+    # the parallel Bezier lines are created with control points of
+    # [c1_left, cm_left, c2_left] and [c1_right, cm_right, c2_right]
+    path_left = [(c1x_left, c1y_left),
+                 (cmx_left, cmy_left),
+                 (c2x_left, c2y_left)]
+    path_right = [(c1x_right, c1y_right),
+                  (cmx_right, cmy_right),
+                  (c2x_right, c2y_right)]
+
+    return path_left, path_right
+
+
+def find_control_points(c1x, c1y, mmx, mmy, c2x, c2y):
+    """
+    Find control points of the Bézier curve passing through (*c1x*, *c1y*),
+    (*mmx*, *mmy*), and (*c2x*, *c2y*), at parametric values 0, 0.5, and 1.
+    """
+    cmx = .5 * (4 * mmx - (c1x + c2x))
+    cmy = .5 * (4 * mmy - (c1y + c2y))
+    return [(c1x, c1y), (cmx, cmy), (c2x, c2y)]
+
+
+def make_wedged_bezier2(bezier2, width, w1=1., wm=0.5, w2=0.):
+    """
+    Being similar to `get_parallels`, returns control points of two quadratic
+    Bézier lines having a width roughly parallel to given one separated by
+    *width*.
+    """
+
+    # c1, cm, c2
+    c1x, c1y = bezier2[0]
+    cmx, cmy = bezier2[1]
+    c3x, c3y = bezier2[2]
+
+    # t1 and t2 is the angle between c1 and cm, cm, c3.
+    # They are also an angle of the tangential line of the path at c1 and c3
+    cos_t1, sin_t1 = get_cos_sin(c1x, c1y, cmx, cmy)
+    cos_t2, sin_t2 = get_cos_sin(cmx, cmy, c3x, c3y)
+
+    # find c1_left, c1_right which are located along the lines
+    # through c1 and perpendicular to the tangential lines of the
+    # Bezier path at a distance of width. Same thing for c3_left and
+    # c3_right with respect to c3.
+    c1x_left, c1y_left, c1x_right, c1y_right = (
+        get_normal_points(c1x, c1y, cos_t1, sin_t1, width * w1)
+    )
+    c3x_left, c3y_left, c3x_right, c3y_right = (
+        get_normal_points(c3x, c3y, cos_t2, sin_t2, width * w2)
+    )
+
+    # find c12, c23 and c123 which are middle points of c1-cm, cm-c3 and
+    # c12-c23
+    c12x, c12y = (c1x + cmx) * .5, (c1y + cmy) * .5
+    c23x, c23y = (cmx + c3x) * .5, (cmy + c3y) * .5
+    c123x, c123y = (c12x + c23x) * .5, (c12y + c23y) * .5
+
+    # tangential angle of c123 (angle between c12 and c23)
+    cos_t123, sin_t123 = get_cos_sin(c12x, c12y, c23x, c23y)
+
+    c123x_left, c123y_left, c123x_right, c123y_right = (
+        get_normal_points(c123x, c123y, cos_t123, sin_t123, width * wm)
+    )
+
+    path_left = find_control_points(c1x_left, c1y_left,
+                                    c123x_left, c123y_left,
+                                    c3x_left, c3y_left)
+    path_right = find_control_points(c1x_right, c1y_right,
+                                     c123x_right, c123y_right,
+                                     c3x_right, c3y_right)
+
+    return path_left, path_right

infer_4_37_2/lib/python3.10/site-packages/matplotlib/category.py

@@ -0,0 +1,235 @@
+"""
+Plotting of string "category" data: ``plot(['d', 'f', 'a'], [1, 2, 3])`` will
+plot three points with x-axis values of 'd', 'f', 'a'.
+
+See :doc:`/gallery/lines_bars_and_markers/categorical_variables` for an
+example.
+
+The module uses Matplotlib's `matplotlib.units` mechanism to convert from
+strings to integers and provides a tick locator, a tick formatter, and the
+`.UnitData` class that creates and stores the string-to-integer mapping.
+"""
+
+from collections import OrderedDict
+import dateutil.parser
+import itertools
+import logging
+
+import numpy as np
+
+from matplotlib import _api, cbook, ticker, units
+
+
+_log = logging.getLogger(__name__)
+
+
+class StrCategoryConverter(units.ConversionInterface):
+    @staticmethod
+    def convert(value, unit, axis):
+        """
+        Convert strings in *value* to floats using mapping information stored
+        in the *unit* object.
+
+        Parameters
+        ----------
+        value : str or iterable
+            Value or list of values to be converted.
+        unit : `.UnitData`
+            An object mapping strings to integers.
+        axis : `~matplotlib.axis.Axis`
+            The axis on which the converted value is plotted.
+
+            .. note:: *axis* is unused.
+
+        Returns
+        -------
+        float or `~numpy.ndarray` of float
+        """
+        if unit is None:
+            raise ValueError(
+                'Missing category information for StrCategoryConverter; '
+                'this might be caused by unintendedly mixing categorical and '
+                'numeric data')
+        StrCategoryConverter._validate_unit(unit)
+        # dtype = object preserves numerical pass throughs
+        values = np.atleast_1d(np.array(value, dtype=object))
+        # force an update so it also does type checking
+        unit.update(values)
+        s = np.vectorize(unit._mapping.__getitem__, otypes=[float])(values)
+        return s if not cbook.is_scalar_or_string(value) else s[0]
+
+    @staticmethod
+    def axisinfo(unit, axis):
+        """
+        Set the default axis ticks and labels.
+
+        Parameters
+        ----------
+        unit : `.UnitData`
+            object string unit information for value
+        axis : `~matplotlib.axis.Axis`
+            axis for which information is being set
+
+            .. note:: *axis* is not used
+
+        Returns
+        -------
+        `~matplotlib.units.AxisInfo`
+            Information to support default tick labeling
+
+        """
+        StrCategoryConverter._validate_unit(unit)
+        # locator and formatter take mapping dict because
+        # args need to be pass by reference for updates
+        majloc = StrCategoryLocator(unit._mapping)
+        majfmt = StrCategoryFormatter(unit._mapping)
+        return units.AxisInfo(majloc=majloc, majfmt=majfmt)
+
+    @staticmethod
+    def default_units(data, axis):
+        """
+        Set and update the `~matplotlib.axis.Axis` units.
+
+        Parameters
+        ----------
+        data : str or iterable of str
+        axis : `~matplotlib.axis.Axis`
+            axis on which the data is plotted
+
+        Returns
+        -------
+        `.UnitData`
+            object storing string to integer mapping
+        """
+        # the conversion call stack is default_units -> axis_info -> convert
+        if axis.units is None:
+            axis.set_units(UnitData(data))
+        else:
+            axis.units.update(data)
+        return axis.units
+
+    @staticmethod
+    def _validate_unit(unit):
+        if not hasattr(unit, '_mapping'):
+            raise ValueError(
+                f'Provided unit "{unit}" is not valid for a categorical '
+                'converter, as it does not have a _mapping attribute.')
+
+
+class StrCategoryLocator(ticker.Locator):
+    """Tick at every integer mapping of the string data."""
+    def __init__(self, units_mapping):
+        """
+        Parameters
+        ----------
+        units_mapping : dict
+            Mapping of category names (str) to indices (int).
+        """
+        self._units = units_mapping
+
+    def __call__(self):
+        # docstring inherited
+        return list(self._units.values())
+
+    def tick_values(self, vmin, vmax):
+        # docstring inherited
+        return self()
+
+
+class StrCategoryFormatter(ticker.Formatter):
+    """String representation of the data at every tick."""
+    def __init__(self, units_mapping):
+        """
+        Parameters
+        ----------
+        units_mapping : dict
+            Mapping of category names (str) to indices (int).
+        """
+        self._units = units_mapping
+
+    def __call__(self, x, pos=None):
+        # docstring inherited
+        return self.format_ticks([x])[0]
+
+    def format_ticks(self, values):
+        # docstring inherited
+        r_mapping = {v: self._text(k) for k, v in self._units.items()}
+        return [r_mapping.get(round(val), '') for val in values]
+
+    @staticmethod
+    def _text(value):
+        """Convert text values into utf-8 or ascii strings."""
+        if isinstance(value, bytes):
+            value = value.decode(encoding='utf-8')
+        elif not isinstance(value, str):
+            value = str(value)
+        return value
+
+
+class UnitData:
+    def __init__(self, data=None):
+        """
+        Create mapping between unique categorical values and integer ids.
+
+        Parameters
+        ----------
+        data : iterable
+            sequence of string values
+        """
+        self._mapping = OrderedDict()
+        self._counter = itertools.count()
+        if data is not None:
+            self.update(data)
+
+    @staticmethod
+    def _str_is_convertible(val):
+        """
+        Helper method to check whether a string can be parsed as float or date.
+        """
+        try:
+            float(val)
+        except ValueError:
+            try:
+                dateutil.parser.parse(val)
+            except (ValueError, TypeError):
+                # TypeError if dateutil >= 2.8.1 else ValueError
+                return False
+        return True
+
+    def update(self, data):
+        """
+        Map new values to integer identifiers.
+
+        Parameters
+        ----------
+        data : iterable of str or bytes
+
+        Raises
+        ------
+        TypeError
+            If elements in *data* are neither str nor bytes.
+        """
+        data = np.atleast_1d(np.array(data, dtype=object))
+        # check if convertible to number:
+        convertible = True
+        for val in OrderedDict.fromkeys(data):
+            # OrderedDict just iterates over unique values in data.
+            _api.check_isinstance((str, bytes), value=val)
+            if convertible:
+                # this will only be called so long as convertible is True.
+                convertible = self._str_is_convertible(val)
+            if val not in self._mapping:
+                self._mapping[val] = next(self._counter)
+        if data.size and convertible:
+            _log.info('Using categorical units to plot a list of strings '
+                      'that are all parsable as floats or dates. If these '
+                      'strings should be plotted as numbers, cast to the '
+                      'appropriate data type before plotting.')
+
+
+# Register the converter with Matplotlib's unit framework
+# Intentionally set to a single instance
+units.registry[str] = \
+    units.registry[np.str_] = \
+    units.registry[bytes] = \
+    units.registry[np.bytes_] = StrCategoryConverter()

infer_4_37_2/lib/python3.10/site-packages/matplotlib/cbook.py

@@ -0,0 +1,2405 @@
+"""
+A collection of utility functions and classes.  Originally, many
+(but not all) were from the Python Cookbook -- hence the name cbook.
+"""
+
+import collections
+import collections.abc
+import contextlib
+import functools
+import gzip
+import itertools
+import math
+import operator
+import os
+from pathlib import Path
+import shlex
+import subprocess
+import sys
+import time
+import traceback
+import types
+import weakref
+
+import numpy as np
+
+try:
+    from numpy.exceptions import VisibleDeprecationWarning  # numpy >= 1.25
+except ImportError:
+    from numpy import VisibleDeprecationWarning
+
+import matplotlib
+from matplotlib import _api, _c_internal_utils
+
+
+class _ExceptionInfo:
+    """
+    A class to carry exception information around.
+
+    This is used to store and later raise exceptions. It's an alternative to
+    directly storing Exception instances that circumvents traceback-related
+    issues: caching tracebacks can keep user's objects in local namespaces
+    alive indefinitely, which can lead to very surprising memory issues for
+    users and result in incorrect tracebacks.
+    """
+
+    def __init__(self, cls, *args):
+        self._cls = cls
+        self._args = args
+
+    @classmethod
+    def from_exception(cls, exc):
+        return cls(type(exc), *exc.args)
+
+    def to_exception(self):
+        return self._cls(*self._args)
+
+
+def _get_running_interactive_framework():
+    """
+    Return the interactive framework whose event loop is currently running, if
+    any, or "headless" if no event loop can be started, or None.
+
+    Returns
+    -------
+    Optional[str]
+        One of the following values: "qt", "gtk3", "gtk4", "wx", "tk",
+        "macosx", "headless", ``None``.
+    """
+    # Use ``sys.modules.get(name)`` rather than ``name in sys.modules`` as
+    # entries can also have been explicitly set to None.
+    QtWidgets = (
+        sys.modules.get("PyQt6.QtWidgets")
+        or sys.modules.get("PySide6.QtWidgets")
+        or sys.modules.get("PyQt5.QtWidgets")
+        or sys.modules.get("PySide2.QtWidgets")
+    )
+    if QtWidgets and QtWidgets.QApplication.instance():
+        return "qt"
+    Gtk = sys.modules.get("gi.repository.Gtk")
+    if Gtk:
+        if Gtk.MAJOR_VERSION == 4:
+            from gi.repository import GLib
+            if GLib.main_depth():
+                return "gtk4"
+        if Gtk.MAJOR_VERSION == 3 and Gtk.main_level():
+            return "gtk3"
+    wx = sys.modules.get("wx")
+    if wx and wx.GetApp():
+        return "wx"
+    tkinter = sys.modules.get("tkinter")
+    if tkinter:
+        codes = {tkinter.mainloop.__code__, tkinter.Misc.mainloop.__code__}
+        for frame in sys._current_frames().values():
+            while frame:
+                if frame.f_code in codes:
+                    return "tk"
+                frame = frame.f_back
+        # Preemptively break reference cycle between locals and the frame.
+        del frame
+    macosx = sys.modules.get("matplotlib.backends._macosx")
+    if macosx and macosx.event_loop_is_running():
+        return "macosx"
+    if not _c_internal_utils.display_is_valid():
+        return "headless"
+    return None
+
+
+def _exception_printer(exc):
+    if _get_running_interactive_framework() in ["headless", None]:
+        raise exc
+    else:
+        traceback.print_exc()
+
+
+class _StrongRef:
+    """
+    Wrapper similar to a weakref, but keeping a strong reference to the object.
+    """
+
+    def __init__(self, obj):
+        self._obj = obj
+
+    def __call__(self):
+        return self._obj
+
+    def __eq__(self, other):
+        return isinstance(other, _StrongRef) and self._obj == other._obj
+
+    def __hash__(self):
+        return hash(self._obj)
+
+
+def _weak_or_strong_ref(func, callback):
+    """
+    Return a `WeakMethod` wrapping *func* if possible, else a `_StrongRef`.
+    """
+    try:
+        return weakref.WeakMethod(func, callback)
+    except TypeError:
+        return _StrongRef(func)
+
+
+class _UnhashDict:
+    """
+    A minimal dict-like class that also supports unhashable keys, storing them
+    in a list of key-value pairs.
+
+    This class only implements the interface needed for `CallbackRegistry`, and
+    tries to minimize the overhead for the hashable case.
+    """
+
+    def __init__(self, pairs):
+        self._dict = {}
+        self._pairs = []
+        for k, v in pairs:
+            self[k] = v
+
+    def __setitem__(self, key, value):
+        try:
+            self._dict[key] = value
+        except TypeError:
+            for i, (k, v) in enumerate(self._pairs):
+                if k == key:
+                    self._pairs[i] = (key, value)
+                    break
+            else:
+                self._pairs.append((key, value))
+
+    def __getitem__(self, key):
+        try:
+            return self._dict[key]
+        except TypeError:
+            pass
+        for k, v in self._pairs:
+            if k == key:
+                return v
+        raise KeyError(key)
+
+    def pop(self, key, *args):
+        try:
+            if key in self._dict:
+                return self._dict.pop(key)
+        except TypeError:
+            for i, (k, v) in enumerate(self._pairs):
+                if k == key:
+                    del self._pairs[i]
+                    return v
+        if args:
+            return args[0]
+        raise KeyError(key)
+
+    def __iter__(self):
+        yield from self._dict
+        for k, v in self._pairs:
+            yield k
+
+
+class CallbackRegistry:
+    """
+    Handle registering, processing, blocking, and disconnecting
+    for a set of signals and callbacks:
+
+        >>> def oneat(x):
+        ...     print('eat', x)
+        >>> def ondrink(x):
+        ...     print('drink', x)
+
+        >>> from matplotlib.cbook import CallbackRegistry
+        >>> callbacks = CallbackRegistry()
+
+        >>> id_eat = callbacks.connect('eat', oneat)
+        >>> id_drink = callbacks.connect('drink', ondrink)
+
+        >>> callbacks.process('drink', 123)
+        drink 123
+        >>> callbacks.process('eat', 456)
+        eat 456
+        >>> callbacks.process('be merry', 456)   # nothing will be called
+
+        >>> callbacks.disconnect(id_eat)
+        >>> callbacks.process('eat', 456)        # nothing will be called
+
+        >>> with callbacks.blocked(signal='drink'):
+        ...     callbacks.process('drink', 123)  # nothing will be called
+        >>> callbacks.process('drink', 123)
+        drink 123
+
+    In practice, one should always disconnect all callbacks when they are
+    no longer needed to avoid dangling references (and thus memory leaks).
+    However, real code in Matplotlib rarely does so, and due to its design,
+    it is rather difficult to place this kind of code.  To get around this,
+    and prevent this class of memory leaks, we instead store weak references
+    to bound methods only, so when the destination object needs to die, the
+    CallbackRegistry won't keep it alive.
+
+    Parameters
+    ----------
+    exception_handler : callable, optional
+       If not None, *exception_handler* must be a function that takes an
+       `Exception` as single parameter.  It gets called with any `Exception`
+       raised by the callbacks during `CallbackRegistry.process`, and may
+       either re-raise the exception or handle it in another manner.
+
+       The default handler prints the exception (with `traceback.print_exc`) if
+       an interactive event loop is running; it re-raises the exception if no
+       interactive event loop is running.
+
+    signals : list, optional
+        If not None, *signals* is a list of signals that this registry handles:
+        attempting to `process` or to `connect` to a signal not in the list
+        throws a `ValueError`.  The default, None, does not restrict the
+        handled signals.
+    """
+
+    # We maintain two mappings:
+    #   callbacks: signal -> {cid -> weakref-to-callback}
+    #   _func_cid_map: {(signal, weakref-to-callback) -> cid}
+
+    def __init__(self, exception_handler=_exception_printer, *, signals=None):
+        self._signals = None if signals is None else list(signals)  # Copy it.
+        self.exception_handler = exception_handler
+        self.callbacks = {}
+        self._cid_gen = itertools.count()
+        self._func_cid_map = _UnhashDict([])
+        # A hidden variable that marks cids that need to be pickled.
+        self._pickled_cids = set()
+
+    def __getstate__(self):
+        return {
+            **vars(self),
+            # In general, callbacks may not be pickled, so we just drop them,
+            # unless directed otherwise by self._pickled_cids.
+            "callbacks": {s: {cid: proxy() for cid, proxy in d.items()
+                              if cid in self._pickled_cids}
+                          for s, d in self.callbacks.items()},
+            # It is simpler to reconstruct this from callbacks in __setstate__.
+            "_func_cid_map": None,
+            "_cid_gen": next(self._cid_gen)
+        }
+
+    def __setstate__(self, state):
+        cid_count = state.pop('_cid_gen')
+        vars(self).update(state)
+        self.callbacks = {
+            s: {cid: _weak_or_strong_ref(func, functools.partial(self._remove_proxy, s))
+                for cid, func in d.items()}
+            for s, d in self.callbacks.items()}
+        self._func_cid_map = _UnhashDict(
+            ((s, proxy), cid)
+            for s, d in self.callbacks.items() for cid, proxy in d.items())
+        self._cid_gen = itertools.count(cid_count)
+
+    def connect(self, signal, func):
+        """Register *func* to be called when signal *signal* is generated."""
+        if self._signals is not None:
+            _api.check_in_list(self._signals, signal=signal)
+        proxy = _weak_or_strong_ref(func, functools.partial(self._remove_proxy, signal))
+        try:
+            return self._func_cid_map[signal, proxy]
+        except KeyError:
+            cid = self._func_cid_map[signal, proxy] = next(self._cid_gen)
+            self.callbacks.setdefault(signal, {})[cid] = proxy
+            return cid
+
+    def _connect_picklable(self, signal, func):
+        """
+        Like `.connect`, but the callback is kept when pickling/unpickling.
+
+        Currently internal-use only.
+        """
+        cid = self.connect(signal, func)
+        self._pickled_cids.add(cid)
+        return cid
+
+    # Keep a reference to sys.is_finalizing, as sys may have been cleared out
+    # at that point.
+    def _remove_proxy(self, signal, proxy, *, _is_finalizing=sys.is_finalizing):
+        if _is_finalizing():
+            # Weakrefs can't be properly torn down at that point anymore.
+            return
+        cid = self._func_cid_map.pop((signal, proxy), None)
+        if cid is not None:
+            del self.callbacks[signal][cid]
+            self._pickled_cids.discard(cid)
+        else:  # Not found
+            return
+        if len(self.callbacks[signal]) == 0:  # Clean up empty dicts
+            del self.callbacks[signal]
+
+    def disconnect(self, cid):
+        """
+        Disconnect the callback registered with callback id *cid*.
+
+        No error is raised if such a callback does not exist.
+        """
+        self._pickled_cids.discard(cid)
+        for signal, proxy in self._func_cid_map:
+            if self._func_cid_map[signal, proxy] == cid:
+                break
+        else:  # Not found
+            return
+        assert self.callbacks[signal][cid] == proxy
+        del self.callbacks[signal][cid]
+        self._func_cid_map.pop((signal, proxy))
+        if len(self.callbacks[signal]) == 0:  # Clean up empty dicts
+            del self.callbacks[signal]
+
+    def process(self, s, *args, **kwargs):
+        """
+        Process signal *s*.
+
+        All of the functions registered to receive callbacks on *s* will be
+        called with ``*args`` and ``**kwargs``.
+        """
+        if self._signals is not None:
+            _api.check_in_list(self._signals, signal=s)
+        for ref in list(self.callbacks.get(s, {}).values()):
+            func = ref()
+            if func is not None:
+                try:
+                    func(*args, **kwargs)
+                # this does not capture KeyboardInterrupt, SystemExit,
+                # and GeneratorExit
+                except Exception as exc:
+                    if self.exception_handler is not None:
+                        self.exception_handler(exc)
+                    else:
+                        raise
+
+    @contextlib.contextmanager
+    def blocked(self, *, signal=None):
+        """
+        Block callback signals from being processed.
+
+        A context manager to temporarily block/disable callback signals
+        from being processed by the registered listeners.
+
+        Parameters
+        ----------
+        signal : str, optional
+            The callback signal to block. The default is to block all signals.
+        """
+        orig = self.callbacks
+        try:
+            if signal is None:
+                # Empty out the callbacks
+                self.callbacks = {}
+            else:
+                # Only remove the specific signal
+                self.callbacks = {k: orig[k] for k in orig if k != signal}
+            yield
+        finally:
+            self.callbacks = orig
+
+
+class silent_list(list):
+    """
+    A list with a short ``repr()``.
+
+    This is meant to be used for a homogeneous list of artists, so that they
+    don't cause long, meaningless output.
+
+    Instead of ::
+
+        [<matplotlib.lines.Line2D object at 0x7f5749fed3c8>,
+         <matplotlib.lines.Line2D object at 0x7f5749fed4e0>,
+         <matplotlib.lines.Line2D object at 0x7f5758016550>]
+
+    one will get ::
+
+        <a list of 3 Line2D objects>
+
+    If ``self.type`` is None, the type name is obtained from the first item in
+    the list (if any).
+    """
+
+    def __init__(self, type, seq=None):
+        self.type = type
+        if seq is not None:
+            self.extend(seq)
+
+    def __repr__(self):
+        if self.type is not None or len(self) != 0:
+            tp = self.type if self.type is not None else type(self[0]).__name__
+            return f"<a list of {len(self)} {tp} objects>"
+        else:
+            return "<an empty list>"
+
+
+def _local_over_kwdict(
+        local_var, kwargs, *keys,
+        warning_cls=_api.MatplotlibDeprecationWarning):
+    out = local_var
+    for key in keys:
+        kwarg_val = kwargs.pop(key, None)
+        if kwarg_val is not None:
+            if out is None:
+                out = kwarg_val
+            else:
+                _api.warn_external(f'"{key}" keyword argument will be ignored',
+                                   warning_cls)
+    return out
+
+
+def strip_math(s):
+    """
+    Remove latex formatting from mathtext.
+
+    Only handles fully math and fully non-math strings.
+    """
+    if len(s) >= 2 and s[0] == s[-1] == "$":
+        s = s[1:-1]
+        for tex, plain in [
+                (r"\times", "x"),  # Specifically for Formatter support.
+                (r"\mathdefault", ""),
+                (r"\rm", ""),
+                (r"\cal", ""),
+                (r"\tt", ""),
+                (r"\it", ""),
+                ("\\", ""),
+                ("{", ""),
+                ("}", ""),
+        ]:
+            s = s.replace(tex, plain)
+    return s
+
+
+def _strip_comment(s):
+    """Strip everything from the first unquoted #."""
+    pos = 0
+    while True:
+        quote_pos = s.find('"', pos)
+        hash_pos = s.find('#', pos)
+        if quote_pos < 0:
+            without_comment = s if hash_pos < 0 else s[:hash_pos]
+            return without_comment.strip()
+        elif 0 <= hash_pos < quote_pos:
+            return s[:hash_pos].strip()
+        else:
+            closing_quote_pos = s.find('"', quote_pos + 1)
+            if closing_quote_pos < 0:
+                raise ValueError(
+                    f"Missing closing quote in: {s!r}. If you need a double-"
+                    'quote inside a string, use escaping: e.g. "the \" char"')
+            pos = closing_quote_pos + 1  # behind closing quote
+
+
+def is_writable_file_like(obj):
+    """Return whether *obj* looks like a file object with a *write* method."""
+    return callable(getattr(obj, 'write', None))
+
+
+def file_requires_unicode(x):
+    """
+    Return whether the given writable file-like object requires Unicode to be
+    written to it.
+    """
+    try:
+        x.write(b'')
+    except TypeError:
+        return True
+    else:
+        return False
+
+
+def to_filehandle(fname, flag='r', return_opened=False, encoding=None):
+    """
+    Convert a path to an open file handle or pass-through a file-like object.
+
+    Consider using `open_file_cm` instead, as it allows one to properly close
+    newly created file objects more easily.
+
+    Parameters
+    ----------
+    fname : str or path-like or file-like
+        If `str` or `os.PathLike`, the file is opened using the flags specified
+        by *flag* and *encoding*.  If a file-like object, it is passed through.
+    flag : str, default: 'r'
+        Passed as the *mode* argument to `open` when *fname* is `str` or
+        `os.PathLike`; ignored if *fname* is file-like.
+    return_opened : bool, default: False
+        If True, return both the file object and a boolean indicating whether
+        this was a new file (that the caller needs to close).  If False, return
+        only the new file.
+    encoding : str or None, default: None
+        Passed as the *mode* argument to `open` when *fname* is `str` or
+        `os.PathLike`; ignored if *fname* is file-like.
+
+    Returns
+    -------
+    fh : file-like
+    opened : bool
+        *opened* is only returned if *return_opened* is True.
+    """
+    if isinstance(fname, os.PathLike):
+        fname = os.fspath(fname)
+    if isinstance(fname, str):
+        if fname.endswith('.gz'):
+            fh = gzip.open(fname, flag)
+        elif fname.endswith('.bz2'):
+            # python may not be compiled with bz2 support,
+            # bury import until we need it
+            import bz2
+            fh = bz2.BZ2File(fname, flag)
+        else:
+            fh = open(fname, flag, encoding=encoding)
+        opened = True
+    elif hasattr(fname, 'seek'):
+        fh = fname
+        opened = False
+    else:
+        raise ValueError('fname must be a PathLike or file handle')
+    if return_opened:
+        return fh, opened
+    return fh
+
+
+def open_file_cm(path_or_file, mode="r", encoding=None):
+    r"""Pass through file objects and context-manage path-likes."""
+    fh, opened = to_filehandle(path_or_file, mode, True, encoding)
+    return fh if opened else contextlib.nullcontext(fh)
+
+
+def is_scalar_or_string(val):
+    """Return whether the given object is a scalar or string like."""
+    return isinstance(val, str) or not np.iterable(val)
+
+
+def get_sample_data(fname, asfileobj=True):
+    """
+    Return a sample data file.  *fname* is a path relative to the
+    :file:`mpl-data/sample_data` directory.  If *asfileobj* is `True`
+    return a file object, otherwise just a file path.
+
+    Sample data files are stored in the 'mpl-data/sample_data' directory within
+    the Matplotlib package.
+
+    If the filename ends in .gz, the file is implicitly ungzipped.  If the
+    filename ends with .npy or .npz, and *asfileobj* is `True`, the file is
+    loaded with `numpy.load`.
+    """
+    path = _get_data_path('sample_data', fname)
+    if asfileobj:
+        suffix = path.suffix.lower()
+        if suffix == '.gz':
+            return gzip.open(path)
+        elif suffix in ['.npy', '.npz']:
+            return np.load(path)
+        elif suffix in ['.csv', '.xrc', '.txt']:
+            return path.open('r')
+        else:
+            return path.open('rb')
+    else:
+        return str(path)
+
+
+def _get_data_path(*args):
+    """
+    Return the `pathlib.Path` to a resource file provided by Matplotlib.
+
+    ``*args`` specify a path relative to the base data path.
+    """
+    return Path(matplotlib.get_data_path(), *args)
+
+
+def flatten(seq, scalarp=is_scalar_or_string):
+    """
+    Return a generator of flattened nested containers.
+
+    For example:
+
+        >>> from matplotlib.cbook import flatten
+        >>> l = (('John', ['Hunter']), (1, 23), [[([42, (5, 23)], )]])
+        >>> print(list(flatten(l)))
+        ['John', 'Hunter', 1, 23, 42, 5, 23]
+
+    By: Composite of Holger Krekel and Luther Blissett
+    From: https://code.activestate.com/recipes/121294-simple-generator-for-flattening-nested-containers/
+    and Recipe 1.12 in cookbook
+    """  # noqa: E501
+    for item in seq:
+        if scalarp(item) or item is None:
+            yield item
+        else:
+            yield from flatten(item, scalarp)
+
+
+class _Stack:
+    """
+    Stack of elements with a movable cursor.
+
+    Mimics home/back/forward in a web browser.
+    """
+
+    def __init__(self):
+        self._pos = -1
+        self._elements = []
+
+    def clear(self):
+        """Empty the stack."""
+        self._pos = -1
+        self._elements = []
+
+    def __call__(self):
+        """Return the current element, or None."""
+        return self._elements[self._pos] if self._elements else None
+
+    def __len__(self):
+        return len(self._elements)
+
+    def __getitem__(self, ind):
+        return self._elements[ind]
+
+    def forward(self):
+        """Move the position forward and return the current element."""
+        self._pos = min(self._pos + 1, len(self._elements) - 1)
+        return self()
+
+    def back(self):
+        """Move the position back and return the current element."""
+        self._pos = max(self._pos - 1, 0)
+        return self()
+
+    def push(self, o):
+        """
+        Push *o* to the stack after the current position, and return *o*.
+
+        Discard all later elements.
+        """
+        self._elements[self._pos + 1:] = [o]
+        self._pos = len(self._elements) - 1
+        return o
+
+    def home(self):
+        """
+        Push the first element onto the top of the stack.
+
+        The first element is returned.
+        """
+        return self.push(self._elements[0]) if self._elements else None
+
+
+def safe_masked_invalid(x, copy=False):
+    x = np.array(x, subok=True, copy=copy)
+    if not x.dtype.isnative:
+        # If we have already made a copy, do the byteswap in place, else make a
+        # copy with the byte order swapped.
+        # Swap to native order.
+        x = x.byteswap(inplace=copy).view(x.dtype.newbyteorder('N'))
+    try:
+        xm = np.ma.masked_where(~(np.isfinite(x)), x, copy=False)
+    except TypeError:
+        return x
+    return xm
+
+
+def print_cycles(objects, outstream=sys.stdout, show_progress=False):
+    """
+    Print loops of cyclic references in the given *objects*.
+
+    It is often useful to pass in ``gc.garbage`` to find the cycles that are
+    preventing some objects from being garbage collected.
+
+    Parameters
+    ----------
+    objects
+        A list of objects to find cycles in.
+    outstream
+        The stream for output.
+    show_progress : bool
+        If True, print the number of objects reached as they are found.
+    """
+    import gc
+
+    def print_path(path):
+        for i, step in enumerate(path):
+            # next "wraps around"
+            next = path[(i + 1) % len(path)]
+
+            outstream.write("   %s -- " % type(step))
+            if isinstance(step, dict):
+                for key, val in step.items():
+                    if val is next:
+                        outstream.write(f"[{key!r}]")
+                        break
+                    if key is next:
+                        outstream.write(f"[key] = {val!r}")
+                        break
+            elif isinstance(step, list):
+                outstream.write("[%d]" % step.index(next))
+            elif isinstance(step, tuple):
+                outstream.write("( tuple )")
+            else:
+                outstream.write(repr(step))
+            outstream.write(" ->\n")
+        outstream.write("\n")
+
+    def recurse(obj, start, all, current_path):
+        if show_progress:
+            outstream.write("%d\r" % len(all))
+
+        all[id(obj)] = None
+
+        referents = gc.get_referents(obj)
+        for referent in referents:
+            # If we've found our way back to the start, this is
+            # a cycle, so print it out
+            if referent is start:
+                print_path(current_path)
+
+            # Don't go back through the original list of objects, or
+            # through temporary references to the object, since those
+            # are just an artifact of the cycle detector itself.
+            elif referent is objects or isinstance(referent, types.FrameType):
+                continue
+
+            # We haven't seen this object before, so recurse
+            elif id(referent) not in all:
+                recurse(referent, start, all, current_path + [obj])
+
+    for obj in objects:
+        outstream.write(f"Examining: {obj!r}\n")
+        recurse(obj, obj, {}, [])
+
+
+class Grouper:
+    """
+    A disjoint-set data structure.
+
+    Objects can be joined using :meth:`join`, tested for connectedness
+    using :meth:`joined`, and all disjoint sets can be retrieved by
+    using the object as an iterator.
+
+    The objects being joined must be hashable and weak-referenceable.
+
+    Examples
+    --------
+    >>> from matplotlib.cbook import Grouper
+    >>> class Foo:
+    ...     def __init__(self, s):
+    ...         self.s = s
+    ...     def __repr__(self):
+    ...         return self.s
+    ...
+    >>> a, b, c, d, e, f = [Foo(x) for x in 'abcdef']
+    >>> grp = Grouper()
+    >>> grp.join(a, b)
+    >>> grp.join(b, c)
+    >>> grp.join(d, e)
+    >>> list(grp)
+    [[a, b, c], [d, e]]
+    >>> grp.joined(a, b)
+    True
+    >>> grp.joined(a, c)
+    True
+    >>> grp.joined(a, d)
+    False
+    """
+
+    def __init__(self, init=()):
+        self._mapping = weakref.WeakKeyDictionary(
+            {x: weakref.WeakSet([x]) for x in init})
+        self._ordering = weakref.WeakKeyDictionary()
+        for x in init:
+            if x not in self._ordering:
+                self._ordering[x] = len(self._ordering)
+        self._next_order = len(self._ordering)  # Plain int to simplify pickling.
+
+    def __getstate__(self):
+        return {
+            **vars(self),
+            # Convert weak refs to strong ones.
+            "_mapping": {k: set(v) for k, v in self._mapping.items()},
+            "_ordering": {**self._ordering},
+        }
+
+    def __setstate__(self, state):
+        vars(self).update(state)
+        # Convert strong refs to weak ones.
+        self._mapping = weakref.WeakKeyDictionary(
+            {k: weakref.WeakSet(v) for k, v in self._mapping.items()})
+        self._ordering = weakref.WeakKeyDictionary(self._ordering)
+
+    def __contains__(self, item):
+        return item in self._mapping
+
+    def join(self, a, *args):
+        """
+        Join given arguments into the same set.  Accepts one or more arguments.
+        """
+        mapping = self._mapping
+        try:
+            set_a = mapping[a]
+        except KeyError:
+            set_a = mapping[a] = weakref.WeakSet([a])
+            self._ordering[a] = self._next_order
+            self._next_order += 1
+        for arg in args:
+            try:
+                set_b = mapping[arg]
+            except KeyError:
+                set_b = mapping[arg] = weakref.WeakSet([arg])
+                self._ordering[arg] = self._next_order
+                self._next_order += 1
+            if set_b is not set_a:
+                if len(set_b) > len(set_a):
+                    set_a, set_b = set_b, set_a
+                set_a.update(set_b)
+                for elem in set_b:
+                    mapping[elem] = set_a
+
+    def joined(self, a, b):
+        """Return whether *a* and *b* are members of the same set."""
+        return (self._mapping.get(a, object()) is self._mapping.get(b))
+
+    def remove(self, a):
+        """Remove *a* from the grouper, doing nothing if it is not there."""
+        self._mapping.pop(a, {a}).remove(a)
+        self._ordering.pop(a, None)
+
+    def __iter__(self):
+        """
+        Iterate over each of the disjoint sets as a list.
+
+        The iterator is invalid if interleaved with calls to join().
+        """
+        unique_groups = {id(group): group for group in self._mapping.values()}
+        for group in unique_groups.values():
+            yield sorted(group, key=self._ordering.__getitem__)
+
+    def get_siblings(self, a):
+        """Return all of the items joined with *a*, including itself."""
+        siblings = self._mapping.get(a, [a])
+        return sorted(siblings, key=self._ordering.get)
+
+
+class GrouperView:
+    """Immutable view over a `.Grouper`."""
+
+    def __init__(self, grouper): self._grouper = grouper
+    def __contains__(self, item): return item in self._grouper
+    def __iter__(self): return iter(self._grouper)
+    def joined(self, a, b): return self._grouper.joined(a, b)
+    def get_siblings(self, a): return self._grouper.get_siblings(a)
+
+
+def simple_linear_interpolation(a, steps):
+    """
+    Resample an array with ``steps - 1`` points between original point pairs.
+
+    Along each column of *a*, ``(steps - 1)`` points are introduced between
+    each original values; the values are linearly interpolated.
+
+    Parameters
+    ----------
+    a : array, shape (n, ...)
+    steps : int
+
+    Returns
+    -------
+    array
+        shape ``((n - 1) * steps + 1, ...)``
+    """
+    fps = a.reshape((len(a), -1))
+    xp = np.arange(len(a)) * steps
+    x = np.arange((len(a) - 1) * steps + 1)
+    return (np.column_stack([np.interp(x, xp, fp) for fp in fps.T])
+            .reshape((len(x),) + a.shape[1:]))
+
+
+def delete_masked_points(*args):
+    """
+    Find all masked and/or non-finite points in a set of arguments,
+    and return the arguments with only the unmasked points remaining.
+
+    Arguments can be in any of 5 categories:
+
+    1) 1-D masked arrays
+    2) 1-D ndarrays
+    3) ndarrays with more than one dimension
+    4) other non-string iterables
+    5) anything else
+
+    The first argument must be in one of the first four categories;
+    any argument with a length differing from that of the first
+    argument (and hence anything in category 5) then will be
+    passed through unchanged.
+
+    Masks are obtained from all arguments of the correct length
+    in categories 1, 2, and 4; a point is bad if masked in a masked
+    array or if it is a nan or inf.  No attempt is made to
+    extract a mask from categories 2, 3, and 4 if `numpy.isfinite`
+    does not yield a Boolean array.
+
+    All input arguments that are not passed unchanged are returned
+    as ndarrays after removing the points or rows corresponding to
+    masks in any of the arguments.
+
+    A vastly simpler version of this function was originally
+    written as a helper for Axes.scatter().
+
+    """
+    if not len(args):
+        return ()
+    if is_scalar_or_string(args[0]):
+        raise ValueError("First argument must be a sequence")
+    nrecs = len(args[0])
+    margs = []
+    seqlist = [False] * len(args)
+    for i, x in enumerate(args):
+        if not isinstance(x, str) and np.iterable(x) and len(x) == nrecs:
+            seqlist[i] = True
+            if isinstance(x, np.ma.MaskedArray):
+                if x.ndim > 1:
+                    raise ValueError("Masked arrays must be 1-D")
+            else:
+                x = np.asarray(x)
+        margs.append(x)
+    masks = []  # List of masks that are True where good.
+    for i, x in enumerate(margs):
+        if seqlist[i]:
+            if x.ndim > 1:
+                continue  # Don't try to get nan locations unless 1-D.
+            if isinstance(x, np.ma.MaskedArray):
+                masks.append(~np.ma.getmaskarray(x))  # invert the mask
+                xd = x.data
+            else:
+                xd = x
+            try:
+                mask = np.isfinite(xd)
+                if isinstance(mask, np.ndarray):
+                    masks.append(mask)
+            except Exception:  # Fixme: put in tuple of possible exceptions?
+                pass
+    if len(masks):
+        mask = np.logical_and.reduce(masks)
+        igood = mask.nonzero()[0]
+        if len(igood) < nrecs:
+            for i, x in enumerate(margs):
+                if seqlist[i]:
+                    margs[i] = x[igood]
+    for i, x in enumerate(margs):
+        if seqlist[i] and isinstance(x, np.ma.MaskedArray):
+            margs[i] = x.filled()
+    return margs
+
+
+def _combine_masks(*args):
+    """
+    Find all masked and/or non-finite points in a set of arguments,
+    and return the arguments as masked arrays with a common mask.
+
+    Arguments can be in any of 5 categories:
+
+    1) 1-D masked arrays
+    2) 1-D ndarrays
+    3) ndarrays with more than one dimension
+    4) other non-string iterables
+    5) anything else
+
+    The first argument must be in one of the first four categories;
+    any argument with a length differing from that of the first
+    argument (and hence anything in category 5) then will be
+    passed through unchanged.
+
+    Masks are obtained from all arguments of the correct length
+    in categories 1, 2, and 4; a point is bad if masked in a masked
+    array or if it is a nan or inf.  No attempt is made to
+    extract a mask from categories 2 and 4 if `numpy.isfinite`
+    does not yield a Boolean array.  Category 3 is included to
+    support RGB or RGBA ndarrays, which are assumed to have only
+    valid values and which are passed through unchanged.
+
+    All input arguments that are not passed unchanged are returned
+    as masked arrays if any masked points are found, otherwise as
+    ndarrays.
+
+    """
+    if not len(args):
+        return ()
+    if is_scalar_or_string(args[0]):
+        raise ValueError("First argument must be a sequence")
+    nrecs = len(args[0])
+    margs = []  # Output args; some may be modified.
+    seqlist = [False] * len(args)  # Flags: True if output will be masked.
+    masks = []    # List of masks.
+    for i, x in enumerate(args):
+        if is_scalar_or_string(x) or len(x) != nrecs:
+            margs.append(x)  # Leave it unmodified.
+        else:
+            if isinstance(x, np.ma.MaskedArray) and x.ndim > 1:
+                raise ValueError("Masked arrays must be 1-D")
+            try:
+                x = np.asanyarray(x)
+            except (VisibleDeprecationWarning, ValueError):
+                # NumPy 1.19 raises a warning about ragged arrays, but we want
+                # to accept basically anything here.
+                x = np.asanyarray(x, dtype=object)
+            if x.ndim == 1:
+                x = safe_masked_invalid(x)
+                seqlist[i] = True
+                if np.ma.is_masked(x):
+                    masks.append(np.ma.getmaskarray(x))
+            margs.append(x)  # Possibly modified.
+    if len(masks):
+        mask = np.logical_or.reduce(masks)
+        for i, x in enumerate(margs):
+            if seqlist[i]:
+                margs[i] = np.ma.array(x, mask=mask)
+    return margs
+
+
+def _broadcast_with_masks(*args, compress=False):
+    """
+    Broadcast inputs, combining all masked arrays.
+
+    Parameters
+    ----------
+    *args : array-like
+        The inputs to broadcast.
+    compress : bool, default: False
+        Whether to compress the masked arrays. If False, the masked values
+        are replaced by NaNs.
+
+    Returns
+    -------
+    list of array-like
+        The broadcasted and masked inputs.
+    """
+    # extract the masks, if any
+    masks = [k.mask for k in args if isinstance(k, np.ma.MaskedArray)]
+    # broadcast to match the shape
+    bcast = np.broadcast_arrays(*args, *masks)
+    inputs = bcast[:len(args)]
+    masks = bcast[len(args):]
+    if masks:
+        # combine the masks into one
+        mask = np.logical_or.reduce(masks)
+        # put mask on and compress
+        if compress:
+            inputs = [np.ma.array(k, mask=mask).compressed()
+                      for k in inputs]
+        else:
+            inputs = [np.ma.array(k, mask=mask, dtype=float).filled(np.nan).ravel()
+                      for k in inputs]
+    else:
+        inputs = [np.ravel(k) for k in inputs]
+    return inputs
+
+
+def boxplot_stats(X, whis=1.5, bootstrap=None, labels=None, autorange=False):
+    r"""
+    Return a list of dictionaries of statistics used to draw a series of box
+    and whisker plots using `~.Axes.bxp`.
+
+    Parameters
+    ----------
+    X : array-like
+        Data that will be represented in the boxplots. Should have 2 or
+        fewer dimensions.
+
+    whis : float or (float, float), default: 1.5
+        The position of the whiskers.
+
+        If a float, the lower whisker is at the lowest datum above
+        ``Q1 - whis*(Q3-Q1)``, and the upper whisker at the highest datum below
+        ``Q3 + whis*(Q3-Q1)``, where Q1 and Q3 are the first and third
+        quartiles.  The default value of ``whis = 1.5`` corresponds to Tukey's
+        original definition of boxplots.
+
+        If a pair of floats, they indicate the percentiles at which to draw the
+        whiskers (e.g., (5, 95)).  In particular, setting this to (0, 100)
+        results in whiskers covering the whole range of the data.
+
+        In the edge case where ``Q1 == Q3``, *whis* is automatically set to
+        (0, 100) (cover the whole range of the data) if *autorange* is True.
+
+        Beyond the whiskers, data are considered outliers and are plotted as
+        individual points.
+
+    bootstrap : int, optional
+        Number of times the confidence intervals around the median
+        should be bootstrapped (percentile method).
+
+    labels : list of str, optional
+        Labels for each dataset. Length must be compatible with
+        dimensions of *X*.
+
+    autorange : bool, optional (False)
+        When `True` and the data are distributed such that the 25th and 75th
+        percentiles are equal, ``whis`` is set to (0, 100) such that the
+        whisker ends are at the minimum and maximum of the data.
+
+    Returns
+    -------
+    list of dict
+        A list of dictionaries containing the results for each column
+        of data. Keys of each dictionary are the following:
+
+        ========   ===================================
+        Key        Value Description
+        ========   ===================================
+        label      tick label for the boxplot
+        mean       arithmetic mean value
+        med        50th percentile
+        q1         first quartile (25th percentile)
+        q3         third quartile (75th percentile)
+        iqr        interquartile range
+        cilo       lower notch around the median
+        cihi       upper notch around the median
+        whislo     end of the lower whisker
+        whishi     end of the upper whisker
+        fliers     outliers
+        ========   ===================================
+
+    Notes
+    -----
+    Non-bootstrapping approach to confidence interval uses Gaussian-based
+    asymptotic approximation:
+
+    .. math::
+
+        \mathrm{med} \pm 1.57 \times \frac{\mathrm{iqr}}{\sqrt{N}}
+
+    General approach from:
+    McGill, R., Tukey, J.W., and Larsen, W.A. (1978) "Variations of
+    Boxplots", The American Statistician, 32:12-16.
+    """
+
+    def _bootstrap_median(data, N=5000):
+        # determine 95% confidence intervals of the median
+        M = len(data)
+        percentiles = [2.5, 97.5]
+
+        bs_index = np.random.randint(M, size=(N, M))
+        bsData = data[bs_index]
+        estimate = np.median(bsData, axis=1, overwrite_input=True)
+
+        CI = np.percentile(estimate, percentiles)
+        return CI
+
+    def _compute_conf_interval(data, med, iqr, bootstrap):
+        if bootstrap is not None:
+            # Do a bootstrap estimate of notch locations.
+            # get conf. intervals around median
+            CI = _bootstrap_median(data, N=bootstrap)
+            notch_min = CI[0]
+            notch_max = CI[1]
+        else:
+
+            N = len(data)
+            notch_min = med - 1.57 * iqr / np.sqrt(N)
+            notch_max = med + 1.57 * iqr / np.sqrt(N)
+
+        return notch_min, notch_max
+
+    # output is a list of dicts
+    bxpstats = []
+
+    # convert X to a list of lists
+    X = _reshape_2D(X, "X")
+
+    ncols = len(X)
+    if labels is None:
+        labels = itertools.repeat(None)
+    elif len(labels) != ncols:
+        raise ValueError("Dimensions of labels and X must be compatible")
+
+    input_whis = whis
+    for ii, (x, label) in enumerate(zip(X, labels)):
+
+        # empty dict
+        stats = {}
+        if label is not None:
+            stats['label'] = label
+
+        # restore whis to the input values in case it got changed in the loop
+        whis = input_whis
+
+        # note tricksiness, append up here and then mutate below
+        bxpstats.append(stats)
+
+        # if empty, bail
+        if len(x) == 0:
+            stats['fliers'] = np.array([])
+            stats['mean'] = np.nan
+            stats['med'] = np.nan
+            stats['q1'] = np.nan
+            stats['q3'] = np.nan
+            stats['iqr'] = np.nan
+            stats['cilo'] = np.nan
+            stats['cihi'] = np.nan
+            stats['whislo'] = np.nan
+            stats['whishi'] = np.nan
+            continue
+
+        # up-convert to an array, just to be safe
+        x = np.ma.asarray(x)
+        x = x.data[~x.mask].ravel()
+
+        # arithmetic mean
+        stats['mean'] = np.mean(x)
+
+        # medians and quartiles
+        q1, med, q3 = np.percentile(x, [25, 50, 75])
+
+        # interquartile range
+        stats['iqr'] = q3 - q1
+        if stats['iqr'] == 0 and autorange:
+            whis = (0, 100)
+
+        # conf. interval around median
+        stats['cilo'], stats['cihi'] = _compute_conf_interval(
+            x, med, stats['iqr'], bootstrap
+        )
+
+        # lowest/highest non-outliers
+        if np.iterable(whis) and not isinstance(whis, str):
+            loval, hival = np.percentile(x, whis)
+        elif np.isreal(whis):
+            loval = q1 - whis * stats['iqr']
+            hival = q3 + whis * stats['iqr']
+        else:
+            raise ValueError('whis must be a float or list of percentiles')
+
+        # get high extreme
+        wiskhi = x[x <= hival]
+        if len(wiskhi) == 0 or np.max(wiskhi) < q3:
+            stats['whishi'] = q3
+        else:
+            stats['whishi'] = np.max(wiskhi)
+
+        # get low extreme
+        wisklo = x[x >= loval]
+        if len(wisklo) == 0 or np.min(wisklo) > q1:
+            stats['whislo'] = q1
+        else:
+            stats['whislo'] = np.min(wisklo)
+
+        # compute a single array of outliers
+        stats['fliers'] = np.concatenate([
+            x[x < stats['whislo']],
+            x[x > stats['whishi']],
+        ])
+
+        # add in the remaining stats
+        stats['q1'], stats['med'], stats['q3'] = q1, med, q3
+
+    return bxpstats
+
+
+#: Maps short codes for line style to their full name used by backends.
+ls_mapper = {'-': 'solid', '--': 'dashed', '-.': 'dashdot', ':': 'dotted'}
+#: Maps full names for line styles used by backends to their short codes.
+ls_mapper_r = {v: k for k, v in ls_mapper.items()}
+
+
+def contiguous_regions(mask):
+    """
+    Return a list of (ind0, ind1) such that ``mask[ind0:ind1].all()`` is
+    True and we cover all such regions.
+    """
+    mask = np.asarray(mask, dtype=bool)
+
+    if not mask.size:
+        return []
+
+    # Find the indices of region changes, and correct offset
+    idx, = np.nonzero(mask[:-1] != mask[1:])
+    idx += 1
+
+    # List operations are faster for moderately sized arrays
+    idx = idx.tolist()
+
+    # Add first and/or last index if needed
+    if mask[0]:
+        idx = [0] + idx
+    if mask[-1]:
+        idx.append(len(mask))
+
+    return list(zip(idx[::2], idx[1::2]))
+
+
+def is_math_text(s):
+    """
+    Return whether the string *s* contains math expressions.
+
+    This is done by checking whether *s* contains an even number of
+    non-escaped dollar signs.
+    """
+    s = str(s)
+    dollar_count = s.count(r'$') - s.count(r'\$')
+    even_dollars = (dollar_count > 0 and dollar_count % 2 == 0)
+    return even_dollars
+
+
+def _to_unmasked_float_array(x):
+    """
+    Convert a sequence to a float array; if input was a masked array, masked
+    values are converted to nans.
+    """
+    if hasattr(x, 'mask'):
+        return np.ma.asarray(x, float).filled(np.nan)
+    else:
+        return np.asarray(x, float)
+
+
+def _check_1d(x):
+    """Convert scalars to 1D arrays; pass-through arrays as is."""
+    # Unpack in case of e.g. Pandas or xarray object
+    x = _unpack_to_numpy(x)
+    # plot requires `shape` and `ndim`.  If passed an
+    # object that doesn't provide them, then force to numpy array.
+    # Note this will strip unit information.
+    if (not hasattr(x, 'shape') or
+            not hasattr(x, 'ndim') or
+            len(x.shape) < 1):
+        return np.atleast_1d(x)
+    else:
+        return x
+
+
+def _reshape_2D(X, name):
+    """
+    Use Fortran ordering to convert ndarrays and lists of iterables to lists of
+    1D arrays.
+
+    Lists of iterables are converted by applying `numpy.asanyarray` to each of
+    their elements.  1D ndarrays are returned in a singleton list containing
+    them.  2D ndarrays are converted to the list of their *columns*.
+
+    *name* is used to generate the error message for invalid inputs.
+    """
+
+    # Unpack in case of e.g. Pandas or xarray object
+    X = _unpack_to_numpy(X)
+
+    # Iterate over columns for ndarrays.
+    if isinstance(X, np.ndarray):
+        X = X.T
+
+        if len(X) == 0:
+            return [[]]
+        elif X.ndim == 1 and np.ndim(X[0]) == 0:
+            # 1D array of scalars: directly return it.
+            return [X]
+        elif X.ndim in [1, 2]:
+            # 2D array, or 1D array of iterables: flatten them first.
+            return [np.reshape(x, -1) for x in X]
+        else:
+            raise ValueError(f'{name} must have 2 or fewer dimensions')
+
+    # Iterate over list of iterables.
+    if len(X) == 0:
+        return [[]]
+
+    result = []
+    is_1d = True
+    for xi in X:
+        # check if this is iterable, except for strings which we
+        # treat as singletons.
+        if not isinstance(xi, str):
+            try:
+                iter(xi)
+            except TypeError:
+                pass
+            else:
+                is_1d = False
+        xi = np.asanyarray(xi)
+        nd = np.ndim(xi)
+        if nd > 1:
+            raise ValueError(f'{name} must have 2 or fewer dimensions')
+        result.append(xi.reshape(-1))
+
+    if is_1d:
+        # 1D array of scalars: directly return it.
+        return [np.reshape(result, -1)]
+    else:
+        # 2D array, or 1D array of iterables: use flattened version.
+        return result
+
+
+def violin_stats(X, method, points=100, quantiles=None):
+    """
+    Return a list of dictionaries of data which can be used to draw a series
+    of violin plots.
+
+    See the ``Returns`` section below to view the required keys of the
+    dictionary.
+
+    Users can skip this function and pass a user-defined set of dictionaries
+    with the same keys to `~.axes.Axes.violinplot` instead of using Matplotlib
+    to do the calculations. See the *Returns* section below for the keys
+    that must be present in the dictionaries.
+
+    Parameters
+    ----------
+    X : array-like
+        Sample data that will be used to produce the gaussian kernel density
+        estimates. Must have 2 or fewer dimensions.
+
+    method : callable
+        The method used to calculate the kernel density estimate for each
+        column of data. When called via ``method(v, coords)``, it should
+        return a vector of the values of the KDE evaluated at the values
+        specified in coords.
+
+    points : int, default: 100
+        Defines the number of points to evaluate each of the gaussian kernel
+        density estimates at.
+
+    quantiles : array-like, default: None
+        Defines (if not None) a list of floats in interval [0, 1] for each
+        column of data, which represents the quantiles that will be rendered
+        for that column of data. Must have 2 or fewer dimensions. 1D array will
+        be treated as a singleton list containing them.
+
+    Returns
+    -------
+    list of dict
+        A list of dictionaries containing the results for each column of data.
+        The dictionaries contain at least the following:
+
+        - coords: A list of scalars containing the coordinates this particular
+          kernel density estimate was evaluated at.
+        - vals: A list of scalars containing the values of the kernel density
+          estimate at each of the coordinates given in *coords*.
+        - mean: The mean value for this column of data.
+        - median: The median value for this column of data.
+        - min: The minimum value for this column of data.
+        - max: The maximum value for this column of data.
+        - quantiles: The quantile values for this column of data.
+    """
+
+    # List of dictionaries describing each of the violins.
+    vpstats = []
+
+    # Want X to be a list of data sequences
+    X = _reshape_2D(X, "X")
+
+    # Want quantiles to be as the same shape as data sequences
+    if quantiles is not None and len(quantiles) != 0:
+        quantiles = _reshape_2D(quantiles, "quantiles")
+    # Else, mock quantiles if it's none or empty
+    else:
+        quantiles = [[]] * len(X)
+
+    # quantiles should have the same size as dataset
+    if len(X) != len(quantiles):
+        raise ValueError("List of violinplot statistics and quantiles values"
+                         " must have the same length")
+
+    # Zip x and quantiles
+    for (x, q) in zip(X, quantiles):
+        # Dictionary of results for this distribution
+        stats = {}
+
+        # Calculate basic stats for the distribution
+        min_val = np.min(x)
+        max_val = np.max(x)
+        quantile_val = np.percentile(x, 100 * q)
+
+        # Evaluate the kernel density estimate
+        coords = np.linspace(min_val, max_val, points)
+        stats['vals'] = method(x, coords)
+        stats['coords'] = coords
+
+        # Store additional statistics for this distribution
+        stats['mean'] = np.mean(x)
+        stats['median'] = np.median(x)
+        stats['min'] = min_val
+        stats['max'] = max_val
+        stats['quantiles'] = np.atleast_1d(quantile_val)
+
+        # Append to output
+        vpstats.append(stats)
+
+    return vpstats
+
+
+def pts_to_prestep(x, *args):
+    """
+    Convert continuous line to pre-steps.
+
+    Given a set of ``N`` points, convert to ``2N - 1`` points, which when
+    connected linearly give a step function which changes values at the
+    beginning of the intervals.
+
+    Parameters
+    ----------
+    x : array
+        The x location of the steps. May be empty.
+
+    y1, ..., yp : array
+        y arrays to be turned into steps; all must be the same length as ``x``.
+
+    Returns
+    -------
+    array
+        The x and y values converted to steps in the same order as the input;
+        can be unpacked as ``x_out, y1_out, ..., yp_out``.  If the input is
+        length ``N``, each of these arrays will be length ``2N + 1``. For
+        ``N=0``, the length will be 0.
+
+    Examples
+    --------
+    >>> x_s, y1_s, y2_s = pts_to_prestep(x, y1, y2)
+    """
+    steps = np.zeros((1 + len(args), max(2 * len(x) - 1, 0)))
+    # In all `pts_to_*step` functions, only assign once using *x* and *args*,
+    # as converting to an array may be expensive.
+    steps[0, 0::2] = x
+    steps[0, 1::2] = steps[0, 0:-2:2]
+    steps[1:, 0::2] = args
+    steps[1:, 1::2] = steps[1:, 2::2]
+    return steps
+
+
+def pts_to_poststep(x, *args):
+    """
+    Convert continuous line to post-steps.
+
+    Given a set of ``N`` points convert to ``2N + 1`` points, which when
+    connected linearly give a step function which changes values at the end of
+    the intervals.
+
+    Parameters
+    ----------
+    x : array
+        The x location of the steps. May be empty.
+
+    y1, ..., yp : array
+        y arrays to be turned into steps; all must be the same length as ``x``.
+
+    Returns
+    -------
+    array
+        The x and y values converted to steps in the same order as the input;
+        can be unpacked as ``x_out, y1_out, ..., yp_out``.  If the input is
+        length ``N``, each of these arrays will be length ``2N + 1``. For
+        ``N=0``, the length will be 0.
+
+    Examples
+    --------
+    >>> x_s, y1_s, y2_s = pts_to_poststep(x, y1, y2)
+    """
+    steps = np.zeros((1 + len(args), max(2 * len(x) - 1, 0)))
+    steps[0, 0::2] = x
+    steps[0, 1::2] = steps[0, 2::2]
+    steps[1:, 0::2] = args
+    steps[1:, 1::2] = steps[1:, 0:-2:2]
+    return steps
+
+
+def pts_to_midstep(x, *args):
+    """
+    Convert continuous line to mid-steps.
+
+    Given a set of ``N`` points convert to ``2N`` points which when connected
+    linearly give a step function which changes values at the middle of the
+    intervals.
+
+    Parameters
+    ----------
+    x : array
+        The x location of the steps. May be empty.
+
+    y1, ..., yp : array
+        y arrays to be turned into steps; all must be the same length as
+        ``x``.
+
+    Returns
+    -------
+    array
+        The x and y values converted to steps in the same order as the input;
+        can be unpacked as ``x_out, y1_out, ..., yp_out``.  If the input is
+        length ``N``, each of these arrays will be length ``2N``.
+
+    Examples
+    --------
+    >>> x_s, y1_s, y2_s = pts_to_midstep(x, y1, y2)
+    """
+    steps = np.zeros((1 + len(args), 2 * len(x)))
+    x = np.asanyarray(x)
+    steps[0, 1:-1:2] = steps[0, 2::2] = (x[:-1] + x[1:]) / 2
+    steps[0, :1] = x[:1]  # Also works for zero-sized input.
+    steps[0, -1:] = x[-1:]
+    steps[1:, 0::2] = args
+    steps[1:, 1::2] = steps[1:, 0::2]
+    return steps
+
+
+STEP_LOOKUP_MAP = {'default': lambda x, y: (x, y),
+                   'steps': pts_to_prestep,
+                   'steps-pre': pts_to_prestep,
+                   'steps-post': pts_to_poststep,
+                   'steps-mid': pts_to_midstep}
+
+
+def index_of(y):
+    """
+    A helper function to create reasonable x values for the given *y*.
+
+    This is used for plotting (x, y) if x values are not explicitly given.
+
+    First try ``y.index`` (assuming *y* is a `pandas.Series`), if that
+    fails, use ``range(len(y))``.
+
+    This will be extended in the future to deal with more types of
+    labeled data.
+
+    Parameters
+    ----------
+    y : float or array-like
+
+    Returns
+    -------
+    x, y : ndarray
+       The x and y values to plot.
+    """
+    try:
+        return y.index.to_numpy(), y.to_numpy()
+    except AttributeError:
+        pass
+    try:
+        y = _check_1d(y)
+    except (VisibleDeprecationWarning, ValueError):
+        # NumPy 1.19 will warn on ragged input, and we can't actually use it.
+        pass
+    else:
+        return np.arange(y.shape[0], dtype=float), y
+    raise ValueError('Input could not be cast to an at-least-1D NumPy array')
+
+
+def safe_first_element(obj):
+    """
+    Return the first element in *obj*.
+
+    This is a type-independent way of obtaining the first element,
+    supporting both index access and the iterator protocol.
+    """
+    if isinstance(obj, collections.abc.Iterator):
+        # needed to accept `array.flat` as input.
+        # np.flatiter reports as an instance of collections.Iterator but can still be
+        # indexed via []. This has the side effect of re-setting the iterator, but
+        # that is acceptable.
+        try:
+            return obj[0]
+        except TypeError:
+            pass
+        raise RuntimeError("matplotlib does not support generators as input")
+    return next(iter(obj))
+
+
+def _safe_first_finite(obj):
+    """
+    Return the first finite element in *obj* if one is available and skip_nonfinite is
+    True. Otherwise, return the first element.
+
+    This is a method for internal use.
+
+    This is a type-independent way of obtaining the first finite element, supporting
+    both index access and the iterator protocol.
+    """
+    def safe_isfinite(val):
+        if val is None:
+            return False
+        try:
+            return math.isfinite(val)
+        except (TypeError, ValueError):
+            # if the outer object is 2d, then val is a 1d array, and
+            # - math.isfinite(numpy.zeros(3)) raises TypeError
+            # - math.isfinite(torch.zeros(3)) raises ValueError
+            pass
+        try:
+            return np.isfinite(val) if np.isscalar(val) else True
+        except TypeError:
+            # This is something that NumPy cannot make heads or tails of,
+            # assume "finite"
+            return True
+
+    if isinstance(obj, np.flatiter):
+        # TODO do the finite filtering on this
+        return obj[0]
+    elif isinstance(obj, collections.abc.Iterator):
+        raise RuntimeError("matplotlib does not support generators as input")
+    else:
+        for val in obj:
+            if safe_isfinite(val):
+                return val
+        return safe_first_element(obj)
+
+
+def sanitize_sequence(data):
+    """
+    Convert dictview objects to list. Other inputs are returned unchanged.
+    """
+    return (list(data) if isinstance(data, collections.abc.MappingView)
+            else data)
+
+
+def normalize_kwargs(kw, alias_mapping=None):
+    """
+    Helper function to normalize kwarg inputs.
+
+    Parameters
+    ----------
+    kw : dict or None
+        A dict of keyword arguments.  None is explicitly supported and treated
+        as an empty dict, to support functions with an optional parameter of
+        the form ``props=None``.
+
+    alias_mapping : dict or Artist subclass or Artist instance, optional
+        A mapping between a canonical name to a list of aliases, in order of
+        precedence from lowest to highest.
+
+        If the canonical value is not in the list it is assumed to have the
+        highest priority.
+
+        If an Artist subclass or instance is passed, use its properties alias
+        mapping.
+
+    Raises
+    ------
+    TypeError
+        To match what Python raises if invalid arguments/keyword arguments are
+        passed to a callable.
+    """
+    from matplotlib.artist import Artist
+
+    if kw is None:
+        return {}
+
+    # deal with default value of alias_mapping
+    if alias_mapping is None:
+        alias_mapping = {}
+    elif (isinstance(alias_mapping, type) and issubclass(alias_mapping, Artist)
+          or isinstance(alias_mapping, Artist)):
+        alias_mapping = getattr(alias_mapping, "_alias_map", {})
+
+    to_canonical = {alias: canonical
+                    for canonical, alias_list in alias_mapping.items()
+                    for alias in alias_list}
+    canonical_to_seen = {}
+    ret = {}  # output dictionary
+
+    for k, v in kw.items():
+        canonical = to_canonical.get(k, k)
+        if canonical in canonical_to_seen:
+            raise TypeError(f"Got both {canonical_to_seen[canonical]!r} and "
+                            f"{k!r}, which are aliases of one another")
+        canonical_to_seen[canonical] = k
+        ret[canonical] = v
+
+    return ret
+
+
+@contextlib.contextmanager
+def _lock_path(path):
+    """
+    Context manager for locking a path.
+
+    Usage::
+
+        with _lock_path(path):
+            ...
+
+    Another thread or process that attempts to lock the same path will wait
+    until this context manager is exited.
+
+    The lock is implemented by creating a temporary file in the parent
+    directory, so that directory must exist and be writable.
+    """
+    path = Path(path)
+    lock_path = path.with_name(path.name + ".matplotlib-lock")
+    retries = 50
+    sleeptime = 0.1
+    for _ in range(retries):
+        try:
+            with lock_path.open("xb"):
+                break
+        except FileExistsError:
+            time.sleep(sleeptime)
+    else:
+        raise TimeoutError("""\
+Lock error: Matplotlib failed to acquire the following lock file:
+    {}
+This maybe due to another process holding this lock file.  If you are sure no
+other Matplotlib process is running, remove this file and try again.""".format(
+            lock_path))
+    try:
+        yield
+    finally:
+        lock_path.unlink()
+
+
+def _topmost_artist(
+        artists,
+        _cached_max=functools.partial(max, key=operator.attrgetter("zorder"))):
+    """
+    Get the topmost artist of a list.
+
+    In case of a tie, return the *last* of the tied artists, as it will be
+    drawn on top of the others. `max` returns the first maximum in case of
+    ties, so we need to iterate over the list in reverse order.
+    """
+    return _cached_max(reversed(artists))
+
+
+def _str_equal(obj, s):
+    """
+    Return whether *obj* is a string equal to string *s*.
+
+    This helper solely exists to handle the case where *obj* is a numpy array,
+    because in such cases, a naive ``obj == s`` would yield an array, which
+    cannot be used in a boolean context.
+    """
+    return isinstance(obj, str) and obj == s
+
+
+def _str_lower_equal(obj, s):
+    """
+    Return whether *obj* is a string equal, when lowercased, to string *s*.
+
+    This helper solely exists to handle the case where *obj* is a numpy array,
+    because in such cases, a naive ``obj == s`` would yield an array, which
+    cannot be used in a boolean context.
+    """
+    return isinstance(obj, str) and obj.lower() == s
+
+
+def _array_perimeter(arr):
+    """
+    Get the elements on the perimeter of *arr*.
+
+    Parameters
+    ----------
+    arr : ndarray, shape (M, N)
+        The input array.
+
+    Returns
+    -------
+    ndarray, shape (2*(M - 1) + 2*(N - 1),)
+        The elements on the perimeter of the array::
+
+           [arr[0, 0], ..., arr[0, -1], ..., arr[-1, -1], ..., arr[-1, 0], ...]
+
+    Examples
+    --------
+    >>> i, j = np.ogrid[:3, :4]
+    >>> a = i*10 + j
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [10, 11, 12, 13],
+           [20, 21, 22, 23]])
+    >>> _array_perimeter(a)
+    array([ 0,  1,  2,  3, 13, 23, 22, 21, 20, 10])
+    """
+    # note we use Python's half-open ranges to avoid repeating
+    # the corners
+    forward = np.s_[0:-1]      # [0 ... -1)
+    backward = np.s_[-1:0:-1]  # [-1 ... 0)
+    return np.concatenate((
+        arr[0, forward],
+        arr[forward, -1],
+        arr[-1, backward],
+        arr[backward, 0],
+    ))
+
+
+def _unfold(arr, axis, size, step):
+    """
+    Append an extra dimension containing sliding windows along *axis*.
+
+    All windows are of size *size* and begin with every *step* elements.
+
+    Parameters
+    ----------
+    arr : ndarray, shape (N_1, ..., N_k)
+        The input array
+    axis : int
+        Axis along which the windows are extracted
+    size : int
+        Size of the windows
+    step : int
+        Stride between first elements of subsequent windows.
+
+    Returns
+    -------
+    ndarray, shape (N_1, ..., 1 + (N_axis-size)/step, ..., N_k, size)
+
+    Examples
+    --------
+    >>> i, j = np.ogrid[:3, :7]
+    >>> a = i*10 + j
+    >>> a
+    array([[ 0,  1,  2,  3,  4,  5,  6],
+           [10, 11, 12, 13, 14, 15, 16],
+           [20, 21, 22, 23, 24, 25, 26]])
+    >>> _unfold(a, axis=1, size=3, step=2)
+    array([[[ 0,  1,  2],
+            [ 2,  3,  4],
+            [ 4,  5,  6]],
+           [[10, 11, 12],
+            [12, 13, 14],
+            [14, 15, 16]],
+           [[20, 21, 22],
+            [22, 23, 24],
+            [24, 25, 26]]])
+    """
+    new_shape = [*arr.shape, size]
+    new_strides = [*arr.strides, arr.strides[axis]]
+    new_shape[axis] = (new_shape[axis] - size) // step + 1
+    new_strides[axis] = new_strides[axis] * step
+    return np.lib.stride_tricks.as_strided(arr,
+                                           shape=new_shape,
+                                           strides=new_strides,
+                                           writeable=False)
+
+
+def _array_patch_perimeters(x, rstride, cstride):
+    """
+    Extract perimeters of patches from *arr*.
+
+    Extracted patches are of size (*rstride* + 1) x (*cstride* + 1) and
+    share perimeters with their neighbors. The ordering of the vertices matches
+    that returned by ``_array_perimeter``.
+
+    Parameters
+    ----------
+    x : ndarray, shape (N, M)
+        Input array
+    rstride : int
+        Vertical (row) stride between corresponding elements of each patch
+    cstride : int
+        Horizontal (column) stride between corresponding elements of each patch
+
+    Returns
+    -------
+    ndarray, shape (N/rstride * M/cstride, 2 * (rstride + cstride))
+    """
+    assert rstride > 0 and cstride > 0
+    assert (x.shape[0] - 1) % rstride == 0
+    assert (x.shape[1] - 1) % cstride == 0
+    # We build up each perimeter from four half-open intervals. Here is an
+    # illustrated explanation for rstride == cstride == 3
+    #
+    #       T T T R
+    #       L     R
+    #       L     R
+    #       L B B B
+    #
+    # where T means that this element will be in the top array, R for right,
+    # B for bottom and L for left. Each of the arrays below has a shape of:
+    #
+    #    (number of perimeters that can be extracted vertically,
+    #     number of perimeters that can be extracted horizontally,
+    #     cstride for top and bottom and rstride for left and right)
+    #
+    # Note that _unfold doesn't incur any memory copies, so the only costly
+    # operation here is the np.concatenate.
+    top = _unfold(x[:-1:rstride, :-1], 1, cstride, cstride)
+    bottom = _unfold(x[rstride::rstride, 1:], 1, cstride, cstride)[..., ::-1]
+    right = _unfold(x[:-1, cstride::cstride], 0, rstride, rstride)
+    left = _unfold(x[1:, :-1:cstride], 0, rstride, rstride)[..., ::-1]
+    return (np.concatenate((top, right, bottom, left), axis=2)
+              .reshape(-1, 2 * (rstride + cstride)))
+
+
+@contextlib.contextmanager
+def _setattr_cm(obj, **kwargs):
+    """
+    Temporarily set some attributes; restore original state at context exit.
+    """
+    sentinel = object()
+    origs = {}
+    for attr in kwargs:
+        orig = getattr(obj, attr, sentinel)
+        if attr in obj.__dict__ or orig is sentinel:
+            # if we are pulling from the instance dict or the object
+            # does not have this attribute we can trust the above
+            origs[attr] = orig
+        else:
+            # if the attribute is not in the instance dict it must be
+            # from the class level
+            cls_orig = getattr(type(obj), attr)
+            # if we are dealing with a property (but not a general descriptor)
+            # we want to set the original value back.
+            if isinstance(cls_orig, property):
+                origs[attr] = orig
+            # otherwise this is _something_ we are going to shadow at
+            # the instance dict level from higher up in the MRO.  We
+            # are going to assume we can delattr(obj, attr) to clean
+            # up after ourselves.  It is possible that this code will
+            # fail if used with a non-property custom descriptor which
+            # implements __set__ (and __delete__ does not act like a
+            # stack).  However, this is an internal tool and we do not
+            # currently have any custom descriptors.
+            else:
+                origs[attr] = sentinel
+
+    try:
+        for attr, val in kwargs.items():
+            setattr(obj, attr, val)
+        yield
+    finally:
+        for attr, orig in origs.items():
+            if orig is sentinel:
+                delattr(obj, attr)
+            else:
+                setattr(obj, attr, orig)
+
+
+class _OrderedSet(collections.abc.MutableSet):
+    def __init__(self):
+        self._od = collections.OrderedDict()
+
+    def __contains__(self, key):
+        return key in self._od
+
+    def __iter__(self):
+        return iter(self._od)
+
+    def __len__(self):
+        return len(self._od)
+
+    def add(self, key):
+        self._od.pop(key, None)
+        self._od[key] = None
+
+    def discard(self, key):
+        self._od.pop(key, None)
+
+
+# Agg's buffers are unmultiplied RGBA8888, which neither PyQt<=5.1 nor cairo
+# support; however, both do support premultiplied ARGB32.
+
+
+def _premultiplied_argb32_to_unmultiplied_rgba8888(buf):
+    """
+    Convert a premultiplied ARGB32 buffer to an unmultiplied RGBA8888 buffer.
+    """
+    rgba = np.take(  # .take() ensures C-contiguity of the result.
+        buf,
+        [2, 1, 0, 3] if sys.byteorder == "little" else [1, 2, 3, 0], axis=2)
+    rgb = rgba[..., :-1]
+    alpha = rgba[..., -1]
+    # Un-premultiply alpha.  The formula is the same as in cairo-png.c.
+    mask = alpha != 0
+    for channel in np.rollaxis(rgb, -1):
+        channel[mask] = (
+            (channel[mask].astype(int) * 255 + alpha[mask] // 2)
+            // alpha[mask])
+    return rgba
+
+
+def _unmultiplied_rgba8888_to_premultiplied_argb32(rgba8888):
+    """
+    Convert an unmultiplied RGBA8888 buffer to a premultiplied ARGB32 buffer.
+    """
+    if sys.byteorder == "little":
+        argb32 = np.take(rgba8888, [2, 1, 0, 3], axis=2)
+        rgb24 = argb32[..., :-1]
+        alpha8 = argb32[..., -1:]
+    else:
+        argb32 = np.take(rgba8888, [3, 0, 1, 2], axis=2)
+        alpha8 = argb32[..., :1]
+        rgb24 = argb32[..., 1:]
+    # Only bother premultiplying when the alpha channel is not fully opaque,
+    # as the cost is not negligible.  The unsafe cast is needed to do the
+    # multiplication in-place in an integer buffer.
+    if alpha8.min() != 0xff:
+        np.multiply(rgb24, alpha8 / 0xff, out=rgb24, casting="unsafe")
+    return argb32
+
+
+def _get_nonzero_slices(buf):
+    """
+    Return the bounds of the nonzero region of a 2D array as a pair of slices.
+
+    ``buf[_get_nonzero_slices(buf)]`` is the smallest sub-rectangle in *buf*
+    that encloses all non-zero entries in *buf*.  If *buf* is fully zero, then
+    ``(slice(0, 0), slice(0, 0))`` is returned.
+    """
+    x_nz, = buf.any(axis=0).nonzero()
+    y_nz, = buf.any(axis=1).nonzero()
+    if len(x_nz) and len(y_nz):
+        l, r = x_nz[[0, -1]]
+        b, t = y_nz[[0, -1]]
+        return slice(b, t + 1), slice(l, r + 1)
+    else:
+        return slice(0, 0), slice(0, 0)
+
+
+def _pformat_subprocess(command):
+    """Pretty-format a subprocess command for printing/logging purposes."""
+    return (command if isinstance(command, str)
+            else " ".join(shlex.quote(os.fspath(arg)) for arg in command))
+
+
+def _check_and_log_subprocess(command, logger, **kwargs):
+    """
+    Run *command*, returning its stdout output if it succeeds.
+
+    If it fails (exits with nonzero return code), raise an exception whose text
+    includes the failed command and captured stdout and stderr output.
+
+    Regardless of the return code, the command is logged at DEBUG level on
+    *logger*.  In case of success, the output is likewise logged.
+    """
+    logger.debug('%s', _pformat_subprocess(command))
+    proc = subprocess.run(command, capture_output=True, **kwargs)
+    if proc.returncode:
+        stdout = proc.stdout
+        if isinstance(stdout, bytes):
+            stdout = stdout.decode()
+        stderr = proc.stderr
+        if isinstance(stderr, bytes):
+            stderr = stderr.decode()
+        raise RuntimeError(
+            f"The command\n"
+            f"    {_pformat_subprocess(command)}\n"
+            f"failed and generated the following output:\n"
+            f"{stdout}\n"
+            f"and the following error:\n"
+            f"{stderr}")
+    if proc.stdout:
+        logger.debug("stdout:\n%s", proc.stdout)
+    if proc.stderr:
+        logger.debug("stderr:\n%s", proc.stderr)
+    return proc.stdout
+
+
+def _setup_new_guiapp():
+    """
+    Perform OS-dependent setup when Matplotlib creates a new GUI application.
+    """
+    # Windows: If not explicit app user model id has been set yet (so we're not
+    # already embedded), then set it to "matplotlib", so that taskbar icons are
+    # correct.
+    try:
+        _c_internal_utils.Win32_GetCurrentProcessExplicitAppUserModelID()
+    except OSError:
+        _c_internal_utils.Win32_SetCurrentProcessExplicitAppUserModelID(
+            "matplotlib")
+
+
+def _format_approx(number, precision):
+    """
+    Format the number with at most the number of decimals given as precision.
+    Remove trailing zeros and possibly the decimal point.
+    """
+    return f'{number:.{precision}f}'.rstrip('0').rstrip('.') or '0'
+
+
+def _g_sig_digits(value, delta):
+    """
+    Return the number of significant digits to %g-format *value*, assuming that
+    it is known with an error of *delta*.
+    """
+    if delta == 0:
+        if value == 0:
+            # if both value and delta are 0, np.spacing below returns 5e-324
+            # which results in rather silly results
+            return 3
+        # delta = 0 may occur when trying to format values over a tiny range;
+        # in that case, replace it by the distance to the closest float.
+        delta = abs(np.spacing(value))
+    # If e.g. value = 45.67 and delta = 0.02, then we want to round to 2 digits
+    # after the decimal point (floor(log10(0.02)) = -2); 45.67 contributes 2
+    # digits before the decimal point (floor(log10(45.67)) + 1 = 2): the total
+    # is 4 significant digits.  A value of 0 contributes 1 "digit" before the
+    # decimal point.
+    # For inf or nan, the precision doesn't matter.
+    return max(
+        0,
+        (math.floor(math.log10(abs(value))) + 1 if value else 1)
+        - math.floor(math.log10(delta))) if math.isfinite(value) else 0
+
+
+def _unikey_or_keysym_to_mplkey(unikey, keysym):
+    """
+    Convert a Unicode key or X keysym to a Matplotlib key name.
+
+    The Unicode key is checked first; this avoids having to list most printable
+    keysyms such as ``EuroSign``.
+    """
+    # For non-printable characters, gtk3 passes "\0" whereas tk passes an "".
+    if unikey and unikey.isprintable():
+        return unikey
+    key = keysym.lower()
+    if key.startswith("kp_"):  # keypad_x (including kp_enter).
+        key = key[3:]
+    if key.startswith("page_"):  # page_{up,down}
+        key = key.replace("page_", "page")
+    if key.endswith(("_l", "_r")):  # alt_l, ctrl_l, shift_l.
+        key = key[:-2]
+    if sys.platform == "darwin" and key == "meta":
+        # meta should be reported as command on mac
+        key = "cmd"
+    key = {
+        "return": "enter",
+        "prior": "pageup",  # Used by tk.
+        "next": "pagedown",  # Used by tk.
+    }.get(key, key)
+    return key
+
+
+@functools.cache
+def _make_class_factory(mixin_class, fmt, attr_name=None):
+    """
+    Return a function that creates picklable classes inheriting from a mixin.
+
+    After ::
+
+        factory = _make_class_factory(FooMixin, fmt, attr_name)
+        FooAxes = factory(Axes)
+
+    ``Foo`` is a class that inherits from ``FooMixin`` and ``Axes`` and **is
+    picklable** (picklability is what differentiates this from a plain call to
+    `type`).  Its ``__name__`` is set to ``fmt.format(Axes.__name__)`` and the
+    base class is stored in the ``attr_name`` attribute, if not None.
+
+    Moreover, the return value of ``factory`` is memoized: calls with the same
+    ``Axes`` class always return the same subclass.
+    """
+
+    @functools.cache
+    def class_factory(axes_class):
+        # if we have already wrapped this class, declare victory!
+        if issubclass(axes_class, mixin_class):
+            return axes_class
+
+        # The parameter is named "axes_class" for backcompat but is really just
+        # a base class; no axes semantics are used.
+        base_class = axes_class
+
+        class subcls(mixin_class, base_class):
+            # Better approximation than __module__ = "matplotlib.cbook".
+            __module__ = mixin_class.__module__
+
+            def __reduce__(self):
+                return (_picklable_class_constructor,
+                        (mixin_class, fmt, attr_name, base_class),
+                        self.__getstate__())
+
+        subcls.__name__ = subcls.__qualname__ = fmt.format(base_class.__name__)
+        if attr_name is not None:
+            setattr(subcls, attr_name, base_class)
+        return subcls
+
+    class_factory.__module__ = mixin_class.__module__
+    return class_factory
+
+
+def _picklable_class_constructor(mixin_class, fmt, attr_name, base_class):
+    """Internal helper for _make_class_factory."""
+    factory = _make_class_factory(mixin_class, fmt, attr_name)
+    cls = factory(base_class)
+    return cls.__new__(cls)
+
+
+def _is_torch_array(x):
+    """Check if 'x' is a PyTorch Tensor."""
+    try:
+        # we're intentionally not attempting to import torch. If somebody
+        # has created a torch array, torch should already be in sys.modules
+        return isinstance(x, sys.modules['torch'].Tensor)
+    except Exception:  # TypeError, KeyError, AttributeError, maybe others?
+        # we're attempting to access attributes on imported modules which
+        # may have arbitrary user code, so we deliberately catch all exceptions
+        return False
+
+
+def _is_jax_array(x):
+    """Check if 'x' is a JAX Array."""
+    try:
+        # we're intentionally not attempting to import jax. If somebody
+        # has created a jax array, jax should already be in sys.modules
+        return isinstance(x, sys.modules['jax'].Array)
+    except Exception:  # TypeError, KeyError, AttributeError, maybe others?
+        # we're attempting to access attributes on imported modules which
+        # may have arbitrary user code, so we deliberately catch all exceptions
+        return False
+
+
+def _is_tensorflow_array(x):
+    """Check if 'x' is a TensorFlow Tensor or Variable."""
+    try:
+        # we're intentionally not attempting to import TensorFlow. If somebody
+        # has created a TensorFlow array, TensorFlow should already be in sys.modules
+        # we use `is_tensor` to not depend on the class structure of TensorFlow
+        # arrays, as `tf.Variables` are not instances of `tf.Tensor`
+        # (they both convert the same way)
+        return isinstance(x, sys.modules['tensorflow'].is_tensor(x))
+    except Exception:  # TypeError, KeyError, AttributeError, maybe others?
+        # we're attempting to access attributes on imported modules which
+        # may have arbitrary user code, so we deliberately catch all exceptions
+        return False
+
+
+def _unpack_to_numpy(x):
+    """Internal helper to extract data from e.g. pandas and xarray objects."""
+    if isinstance(x, np.ndarray):
+        # If numpy, return directly
+        return x
+    if hasattr(x, 'to_numpy'):
+        # Assume that any to_numpy() method actually returns a numpy array
+        return x.to_numpy()
+    if hasattr(x, 'values'):
+        xtmp = x.values
+        # For example a dict has a 'values' attribute, but it is not a property
+        # so in this case we do not want to return a function
+        if isinstance(xtmp, np.ndarray):
+            return xtmp
+    if _is_torch_array(x) or _is_jax_array(x) or _is_tensorflow_array(x):
+        # using np.asarray() instead of explicitly __array__(), as the latter is
+        # only _one_ of many methods, and it's the last resort, see also
+        # https://numpy.org/devdocs/user/basics.interoperability.html#using-arbitrary-objects-in-numpy
+        # therefore, let arrays do better if they can
+        xtmp = np.asarray(x)
+
+        # In case np.asarray method does not return a numpy array in future
+        if isinstance(xtmp, np.ndarray):
+            return xtmp
+    return x
+
+
+def _auto_format_str(fmt, value):
+    """
+    Apply *value* to the format string *fmt*.
+
+    This works both with unnamed %-style formatting and
+    unnamed {}-style formatting. %-style formatting has priority.
+    If *fmt* is %-style formattable that will be used. Otherwise,
+    {}-formatting is applied. Strings without formatting placeholders
+    are passed through as is.
+
+    Examples
+    --------
+    >>> _auto_format_str('%.2f m', 0.2)
+    '0.20 m'
+    >>> _auto_format_str('{} m', 0.2)
+    '0.2 m'
+    >>> _auto_format_str('const', 0.2)
+    'const'
+    >>> _auto_format_str('%d or {}', 0.2)
+    '0 or {}'
+    """
+    try:
+        return fmt % (value,)
+    except (TypeError, ValueError):
+        return fmt.format(value)
+
+
+def _is_pandas_dataframe(x):
+    """Check if 'x' is a Pandas DataFrame."""
+    try:
+        # we're intentionally not attempting to import Pandas. If somebody
+        # has created a Pandas DataFrame, Pandas should already be in sys.modules
+        return isinstance(x, sys.modules['pandas'].DataFrame)
+    except Exception:  # TypeError, KeyError, AttributeError, maybe others?
+        # we're attempting to access attributes on imported modules which
+        # may have arbitrary user code, so we deliberately catch all exceptions
+        return False

infer_4_37_2/lib/python3.10/site-packages/matplotlib/collections.py

@@ -0,0 +1,2582 @@
+"""
+Classes for the efficient drawing of large collections of objects that
+share most properties, e.g., a large number of line segments or
+polygons.
+
+The classes are not meant to be as flexible as their single element
+counterparts (e.g., you may not be able to select all line styles) but
+they are meant to be fast for common use cases (e.g., a large set of solid
+line segments).
+"""
+
+import itertools
+import functools
+import math
+from numbers import Number, Real
+import warnings
+
+import numpy as np
+
+import matplotlib as mpl
+from . import (_api, _path, artist, cbook, colorizer as mcolorizer, colors as mcolors,
+               _docstring, hatch as mhatch, lines as mlines, path as mpath, transforms)
+from ._enums import JoinStyle, CapStyle
+
+
+# "color" is excluded; it is a compound setter, and its docstring differs
+# in LineCollection.
+@_api.define_aliases({
+    "antialiased": ["antialiaseds", "aa"],
+    "edgecolor": ["edgecolors", "ec"],
+    "facecolor": ["facecolors", "fc"],
+    "linestyle": ["linestyles", "dashes", "ls"],
+    "linewidth": ["linewidths", "lw"],
+    "offset_transform": ["transOffset"],
+})
+class Collection(mcolorizer.ColorizingArtist):
+    r"""
+    Base class for Collections. Must be subclassed to be usable.
+
+    A Collection represents a sequence of `.Patch`\es that can be drawn
+    more efficiently together than individually. For example, when a single
+    path is being drawn repeatedly at different offsets, the renderer can
+    typically execute a ``draw_marker()`` call much more efficiently than a
+    series of repeated calls to ``draw_path()`` with the offsets put in
+    one-by-one.
+
+    Most properties of a collection can be configured per-element. Therefore,
+    Collections have "plural" versions of many of the properties of a `.Patch`
+    (e.g. `.Collection.get_paths` instead of `.Patch.get_path`). Exceptions are
+    the *zorder*, *hatch*, *pickradius*, *capstyle* and *joinstyle* properties,
+    which can only be set globally for the whole collection.
+
+    Besides these exceptions, all properties can be specified as single values
+    (applying to all elements) or sequences of values. The property of the
+    ``i``\th element of the collection is::
+
+      prop[i % len(prop)]
+
+    Each Collection can optionally be used as its own `.ScalarMappable` by
+    passing the *norm* and *cmap* parameters to its constructor. If the
+    Collection's `.ScalarMappable` matrix ``_A`` has been set (via a call
+    to `.Collection.set_array`), then at draw time this internal scalar
+    mappable will be used to set the ``facecolors`` and ``edgecolors``,
+    ignoring those that were manually passed in.
+    """
+    #: Either a list of 3x3 arrays or an Nx3x3 array (representing N
+    #: transforms), suitable for the `all_transforms` argument to
+    #: `~matplotlib.backend_bases.RendererBase.draw_path_collection`;
+    #: each 3x3 array is used to initialize an
+    #: `~matplotlib.transforms.Affine2D` object.
+    #: Each kind of collection defines this based on its arguments.
+    _transforms = np.empty((0, 3, 3))
+
+    # Whether to draw an edge by default.  Set on a
+    # subclass-by-subclass basis.
+    _edge_default = False
+
+    @_docstring.interpd
+    def __init__(self, *,
+                 edgecolors=None,
+                 facecolors=None,
+                 linewidths=None,
+                 linestyles='solid',
+                 capstyle=None,
+                 joinstyle=None,
+                 antialiaseds=None,
+                 offsets=None,
+                 offset_transform=None,
+                 norm=None,  # optional for ScalarMappable
+                 cmap=None,  # ditto
+                 colorizer=None,
+                 pickradius=5.0,
+                 hatch=None,
+                 urls=None,
+                 zorder=1,
+                 **kwargs
+                 ):
+        """
+        Parameters
+        ----------
+        edgecolors : :mpltype:`color` or list of colors, default: :rc:`patch.edgecolor`
+            Edge color for each patch making up the collection. The special
+            value 'face' can be passed to make the edgecolor match the
+            facecolor.
+        facecolors : :mpltype:`color` or list of colors, default: :rc:`patch.facecolor`
+            Face color for each patch making up the collection.
+        linewidths : float or list of floats, default: :rc:`patch.linewidth`
+            Line width for each patch making up the collection.
+        linestyles : str or tuple or list thereof, default: 'solid'
+            Valid strings are ['solid', 'dashed', 'dashdot', 'dotted', '-',
+            '--', '-.', ':']. Dash tuples should be of the form::
+
+                (offset, onoffseq),
+
+            where *onoffseq* is an even length tuple of on and off ink lengths
+            in points. For examples, see
+            :doc:`/gallery/lines_bars_and_markers/linestyles`.
+        capstyle : `.CapStyle`-like, default: 'butt'
+            Style to use for capping lines for all paths in the collection.
+            Allowed values are %(CapStyle)s.
+        joinstyle : `.JoinStyle`-like, default: 'round'
+            Style to use for joining lines for all paths in the collection.
+            Allowed values are %(JoinStyle)s.
+        antialiaseds : bool or list of bool, default: :rc:`patch.antialiased`
+            Whether each patch in the collection should be drawn with
+            antialiasing.
+        offsets : (float, float) or list thereof, default: (0, 0)
+            A vector by which to translate each patch after rendering (default
+            is no translation). The translation is performed in screen (pixel)
+            coordinates (i.e. after the Artist's transform is applied).
+        offset_transform : `~.Transform`, default: `.IdentityTransform`
+            A single transform which will be applied to each *offsets* vector
+            before it is used.
+        cmap, norm
+            Data normalization and colormapping parameters. See
+            `.ScalarMappable` for a detailed description.
+        hatch : str, optional
+            Hatching pattern to use in filled paths, if any. Valid strings are
+            ['/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*']. See
+            :doc:`/gallery/shapes_and_collections/hatch_style_reference` for
+            the meaning of each hatch type.
+        pickradius : float, default: 5.0
+            If ``pickradius <= 0``, then `.Collection.contains` will return
+            ``True`` whenever the test point is inside of one of the polygons
+            formed by the control points of a Path in the Collection. On the
+            other hand, if it is greater than 0, then we instead check if the
+            test point is contained in a stroke of width ``2*pickradius``
+            following any of the Paths in the Collection.
+        urls : list of str, default: None
+            A URL for each patch to link to once drawn. Currently only works
+            for the SVG backend. See :doc:`/gallery/misc/hyperlinks_sgskip` for
+            examples.
+        zorder : float, default: 1
+            The drawing order, shared by all Patches in the Collection. See
+            :doc:`/gallery/misc/zorder_demo` for all defaults and examples.
+        **kwargs
+            Remaining keyword arguments will be used to set properties as
+            ``Collection.set_{key}(val)`` for each key-value pair in *kwargs*.
+        """
+
+        super().__init__(self._get_colorizer(cmap, norm, colorizer))
+        # list of un-scaled dash patterns
+        # this is needed scaling the dash pattern by linewidth
+        self._us_linestyles = [(0, None)]
+        # list of dash patterns
+        self._linestyles = [(0, None)]
+        # list of unbroadcast/scaled linewidths
+        self._us_lw = [0]
+        self._linewidths = [0]
+
+        self._gapcolor = None  # Currently only used by LineCollection.
+
+        # Flags set by _set_mappable_flags: are colors from mapping an array?
+        self._face_is_mapped = None
+        self._edge_is_mapped = None
+        self._mapped_colors = None  # calculated in update_scalarmappable
+        self._hatch_color = mcolors.to_rgba(mpl.rcParams['hatch.color'])
+        self._hatch_linewidth = mpl.rcParams['hatch.linewidth']
+        self.set_facecolor(facecolors)
+        self.set_edgecolor(edgecolors)
+        self.set_linewidth(linewidths)
+        self.set_linestyle(linestyles)
+        self.set_antialiased(antialiaseds)
+        self.set_pickradius(pickradius)
+        self.set_urls(urls)
+        self.set_hatch(hatch)
+        self.set_zorder(zorder)
+
+        if capstyle:
+            self.set_capstyle(capstyle)
+        else:
+            self._capstyle = None
+
+        if joinstyle:
+            self.set_joinstyle(joinstyle)
+        else:
+            self._joinstyle = None
+
+        if offsets is not None:
+            offsets = np.asanyarray(offsets, float)
+            # Broadcast (2,) -> (1, 2) but nothing else.
+            if offsets.shape == (2,):
+                offsets = offsets[None, :]
+
+        self._offsets = offsets
+        self._offset_transform = offset_transform
+
+        self._path_effects = None
+        self._internal_update(kwargs)
+        self._paths = None
+
+    def get_paths(self):
+        return self._paths
+
+    def set_paths(self, paths):
+        self._paths = paths
+        self.stale = True
+
+    def get_transforms(self):
+        return self._transforms
+
+    def get_offset_transform(self):
+        """Return the `.Transform` instance used by this artist offset."""
+        if self._offset_transform is None:
+            self._offset_transform = transforms.IdentityTransform()
+        elif (not isinstance(self._offset_transform, transforms.Transform)
+              and hasattr(self._offset_transform, '_as_mpl_transform')):
+            self._offset_transform = \
+                self._offset_transform._as_mpl_transform(self.axes)
+        return self._offset_transform
+
+    def set_offset_transform(self, offset_transform):
+        """
+        Set the artist offset transform.
+
+        Parameters
+        ----------
+        offset_transform : `.Transform`
+        """
+        self._offset_transform = offset_transform
+
+    def get_datalim(self, transData):
+        # Calculate the data limits and return them as a `.Bbox`.
+        #
+        # This operation depends on the transforms for the data in the
+        # collection and whether the collection has offsets:
+        #
+        # 1. offsets = None, transform child of transData: use the paths for
+        # the automatic limits (i.e. for LineCollection in streamline).
+        # 2. offsets != None: offset_transform is child of transData:
+        #
+        #    a. transform is child of transData: use the path + offset for
+        #       limits (i.e for bar).
+        #    b. transform is not a child of transData: just use the offsets
+        #       for the limits (i.e. for scatter)
+        #
+        # 3. otherwise return a null Bbox.
+
+        transform = self.get_transform()
+        offset_trf = self.get_offset_transform()
+        if not (isinstance(offset_trf, transforms.IdentityTransform)
+                or offset_trf.contains_branch(transData)):
+            # if the offsets are in some coords other than data,
+            # then don't use them for autoscaling.
+            return transforms.Bbox.null()
+
+        paths = self.get_paths()
+        if not len(paths):
+            # No paths to transform
+            return transforms.Bbox.null()
+
+        if not transform.is_affine:
+            paths = [transform.transform_path_non_affine(p) for p in paths]
+            # Don't convert transform to transform.get_affine() here because
+            # we may have transform.contains_branch(transData) but not
+            # transforms.get_affine().contains_branch(transData).  But later,
+            # be careful to only apply the affine part that remains.
+
+        offsets = self.get_offsets()
+
+        if any(transform.contains_branch_seperately(transData)):
+            # collections that are just in data units (like quiver)
+            # can properly have the axes limits set by their shape +
+            # offset.  LineCollections that have no offsets can
+            # also use this algorithm (like streamplot).
+            if isinstance(offsets, np.ma.MaskedArray):
+                offsets = offsets.filled(np.nan)
+                # get_path_collection_extents handles nan but not masked arrays
+            return mpath.get_path_collection_extents(
+                transform.get_affine() - transData, paths,
+                self.get_transforms(),
+                offset_trf.transform_non_affine(offsets),
+                offset_trf.get_affine().frozen())
+
+        # NOTE: None is the default case where no offsets were passed in
+        if self._offsets is not None:
+            # this is for collections that have their paths (shapes)
+            # in physical, axes-relative, or figure-relative units
+            # (i.e. like scatter). We can't uniquely set limits based on
+            # those shapes, so we just set the limits based on their
+            # location.
+            offsets = (offset_trf - transData).transform(offsets)
+            # note A-B means A B^{-1}
+            offsets = np.ma.masked_invalid(offsets)
+            if not offsets.mask.all():
+                bbox = transforms.Bbox.null()
+                bbox.update_from_data_xy(offsets)
+                return bbox
+        return transforms.Bbox.null()
+
+    def get_window_extent(self, renderer=None):
+        # TODO: check to ensure that this does not fail for
+        # cases other than scatter plot legend
+        return self.get_datalim(transforms.IdentityTransform())
+
+    def _prepare_points(self):
+        # Helper for drawing and hit testing.
+
+        transform = self.get_transform()
+        offset_trf = self.get_offset_transform()
+        offsets = self.get_offsets()
+        paths = self.get_paths()
+
+        if self.have_units():
+            paths = []
+            for path in self.get_paths():
+                vertices = path.vertices
+                xs, ys = vertices[:, 0], vertices[:, 1]
+                xs = self.convert_xunits(xs)
+                ys = self.convert_yunits(ys)
+                paths.append(mpath.Path(np.column_stack([xs, ys]), path.codes))
+            xs = self.convert_xunits(offsets[:, 0])
+            ys = self.convert_yunits(offsets[:, 1])
+            offsets = np.ma.column_stack([xs, ys])
+
+        if not transform.is_affine:
+            paths = [transform.transform_path_non_affine(path)
+                     for path in paths]
+            transform = transform.get_affine()
+        if not offset_trf.is_affine:
+            offsets = offset_trf.transform_non_affine(offsets)
+            # This might have changed an ndarray into a masked array.
+            offset_trf = offset_trf.get_affine()
+
+        if isinstance(offsets, np.ma.MaskedArray):
+            offsets = offsets.filled(np.nan)
+            # Changing from a masked array to nan-filled ndarray
+            # is probably most efficient at this point.
+
+        return transform, offset_trf, offsets, paths
+
+    @artist.allow_rasterization
+    def draw(self, renderer):
+        if not self.get_visible():
+            return
+        renderer.open_group(self.__class__.__name__, self.get_gid())
+
+        self.update_scalarmappable()
+
+        transform, offset_trf, offsets, paths = self._prepare_points()
+
+        gc = renderer.new_gc()
+        self._set_gc_clip(gc)
+        gc.set_snap(self.get_snap())
+
+        if self._hatch:
+            gc.set_hatch(self._hatch)
+            gc.set_hatch_color(self._hatch_color)
+            gc.set_hatch_linewidth(self._hatch_linewidth)
+
+        if self.get_sketch_params() is not None:
+            gc.set_sketch_params(*self.get_sketch_params())
+
+        if self.get_path_effects():
+            from matplotlib.patheffects import PathEffectRenderer
+            renderer = PathEffectRenderer(self.get_path_effects(), renderer)
+
+        # If the collection is made up of a single shape/color/stroke,
+        # it can be rendered once and blitted multiple times, using
+        # `draw_markers` rather than `draw_path_collection`.  This is
+        # *much* faster for Agg, and results in smaller file sizes in
+        # PDF/SVG/PS.
+
+        trans = self.get_transforms()
+        facecolors = self.get_facecolor()
+        edgecolors = self.get_edgecolor()
+        do_single_path_optimization = False
+        if (len(paths) == 1 and len(trans) <= 1 and
+                len(facecolors) == 1 and len(edgecolors) == 1 and
+                len(self._linewidths) == 1 and
+                all(ls[1] is None for ls in self._linestyles) and
+                len(self._antialiaseds) == 1 and len(self._urls) == 1 and
+                self.get_hatch() is None):
+            if len(trans):
+                combined_transform = transforms.Affine2D(trans[0]) + transform
+            else:
+                combined_transform = transform
+            extents = paths[0].get_extents(combined_transform)
+            if (extents.width < self.get_figure(root=True).bbox.width
+                    and extents.height < self.get_figure(root=True).bbox.height):
+                do_single_path_optimization = True
+
+        if self._joinstyle:
+            gc.set_joinstyle(self._joinstyle)
+
+        if self._capstyle:
+            gc.set_capstyle(self._capstyle)
+
+        if do_single_path_optimization:
+            gc.set_foreground(tuple(edgecolors[0]))
+            gc.set_linewidth(self._linewidths[0])
+            gc.set_dashes(*self._linestyles[0])
+            gc.set_antialiased(self._antialiaseds[0])
+            gc.set_url(self._urls[0])
+            renderer.draw_markers(
+                gc, paths[0], combined_transform.frozen(),
+                mpath.Path(offsets), offset_trf, tuple(facecolors[0]))
+        else:
+            if self._gapcolor is not None:
+                # First draw paths within the gaps.
+                ipaths, ilinestyles = self._get_inverse_paths_linestyles()
+                renderer.draw_path_collection(
+                    gc, transform.frozen(), ipaths,
+                    self.get_transforms(), offsets, offset_trf,
+                    [mcolors.to_rgba("none")], self._gapcolor,
+                    self._linewidths, ilinestyles,
+                    self._antialiaseds, self._urls,
+                    "screen")
+
+            renderer.draw_path_collection(
+                gc, transform.frozen(), paths,
+                self.get_transforms(), offsets, offset_trf,
+                self.get_facecolor(), self.get_edgecolor(),
+                self._linewidths, self._linestyles,
+                self._antialiaseds, self._urls,
+                "screen")  # offset_position, kept for backcompat.
+
+        gc.restore()
+        renderer.close_group(self.__class__.__name__)
+        self.stale = False
+
+    def set_pickradius(self, pickradius):
+        """
+        Set the pick radius used for containment tests.
+
+        Parameters
+        ----------
+        pickradius : float
+            Pick radius, in points.
+        """
+        if not isinstance(pickradius, Real):
+            raise ValueError(
+                f"pickradius must be a real-valued number, not {pickradius!r}")
+        self._pickradius = pickradius
+
+    def get_pickradius(self):
+        return self._pickradius
+
+    def contains(self, mouseevent):
+        """
+        Test whether the mouse event occurred in the collection.
+
+        Returns ``bool, dict(ind=itemlist)``, where every item in itemlist
+        contains the event.
+        """
+        if self._different_canvas(mouseevent) or not self.get_visible():
+            return False, {}
+        pickradius = (
+            float(self._picker)
+            if isinstance(self._picker, Number) and
+               self._picker is not True  # the bool, not just nonzero or 1
+            else self._pickradius)
+        if self.axes:
+            self.axes._unstale_viewLim()
+        transform, offset_trf, offsets, paths = self._prepare_points()
+        # Tests if the point is contained on one of the polygons formed
+        # by the control points of each of the paths. A point is considered
+        # "on" a path if it would lie within a stroke of width 2*pickradius
+        # following the path. If pickradius <= 0, then we instead simply check
+        # if the point is *inside* of the path instead.
+        ind = _path.point_in_path_collection(
+            mouseevent.x, mouseevent.y, pickradius,
+            transform.frozen(), paths, self.get_transforms(),
+            offsets, offset_trf, pickradius <= 0)
+        return len(ind) > 0, dict(ind=ind)
+
+    def set_urls(self, urls):
+        """
+        Parameters
+        ----------
+        urls : list of str or None
+
+        Notes
+        -----
+        URLs are currently only implemented by the SVG backend. They are
+        ignored by all other backends.
+        """
+        self._urls = urls if urls is not None else [None]
+        self.stale = True
+
+    def get_urls(self):
+        """
+        Return a list of URLs, one for each element of the collection.
+
+        The list contains *None* for elements without a URL. See
+        :doc:`/gallery/misc/hyperlinks_sgskip` for an example.
+        """
+        return self._urls
+
+    def set_hatch(self, hatch):
+        r"""
+        Set the hatching pattern
+
+        *hatch* can be one of::
+
+          /   - diagonal hatching
+          \   - back diagonal
+          |   - vertical
+          -   - horizontal
+          +   - crossed
+          x   - crossed diagonal
+          o   - small circle
+          O   - large circle
+          .   - dots
+          *   - stars
+
+        Letters can be combined, in which case all the specified
+        hatchings are done.  If same letter repeats, it increases the
+        density of hatching of that pattern.
+
+        Unlike other properties such as linewidth and colors, hatching
+        can only be specified for the collection as a whole, not separately
+        for each member.
+
+        Parameters
+        ----------
+        hatch : {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
+        """
+        # Use validate_hatch(list) after deprecation.
+        mhatch._validate_hatch_pattern(hatch)
+        self._hatch = hatch
+        self.stale = True
+
+    def get_hatch(self):
+        """Return the current hatching pattern."""
+        return self._hatch
+
+    def set_hatch_linewidth(self, lw):
+        """Set the hatch linewidth."""
+        self._hatch_linewidth = lw
+
+    def get_hatch_linewidth(self):
+        """Return the hatch linewidth."""
+        return self._hatch_linewidth
+
+    def set_offsets(self, offsets):
+        """
+        Set the offsets for the collection.
+
+        Parameters
+        ----------
+        offsets : (N, 2) or (2,) array-like
+        """
+        offsets = np.asanyarray(offsets)
+        if offsets.shape == (2,):  # Broadcast (2,) -> (1, 2) but nothing else.
+            offsets = offsets[None, :]
+        cstack = (np.ma.column_stack if isinstance(offsets, np.ma.MaskedArray)
+                  else np.column_stack)
+        self._offsets = cstack(
+            (np.asanyarray(self.convert_xunits(offsets[:, 0]), float),
+             np.asanyarray(self.convert_yunits(offsets[:, 1]), float)))
+        self.stale = True
+
+    def get_offsets(self):
+        """Return the offsets for the collection."""
+        # Default to zeros in the no-offset (None) case
+        return np.zeros((1, 2)) if self._offsets is None else self._offsets
+
+    def _get_default_linewidth(self):
+        # This may be overridden in a subclass.
+        return mpl.rcParams['patch.linewidth']  # validated as float
+
+    def set_linewidth(self, lw):
+        """
+        Set the linewidth(s) for the collection.  *lw* can be a scalar
+        or a sequence; if it is a sequence the patches will cycle
+        through the sequence
+
+        Parameters
+        ----------
+        lw : float or list of floats
+        """
+        if lw is None:
+            lw = self._get_default_linewidth()
+        # get the un-scaled/broadcast lw
+        self._us_lw = np.atleast_1d(lw)
+
+        # scale all of the dash patterns.
+        self._linewidths, self._linestyles = self._bcast_lwls(
+            self._us_lw, self._us_linestyles)
+        self.stale = True
+
+    def set_linestyle(self, ls):
+        """
+        Set the linestyle(s) for the collection.
+
+        ===========================   =================
+        linestyle                     description
+        ===========================   =================
+        ``'-'`` or ``'solid'``        solid line
+        ``'--'`` or  ``'dashed'``     dashed line
+        ``'-.'`` or  ``'dashdot'``    dash-dotted line
+        ``':'`` or ``'dotted'``       dotted line
+        ===========================   =================
+
+        Alternatively a dash tuple of the following form can be provided::
+
+            (offset, onoffseq),
+
+        where ``onoffseq`` is an even length tuple of on and off ink in points.
+
+        Parameters
+        ----------
+        ls : str or tuple or list thereof
+            Valid values for individual linestyles include {'-', '--', '-.',
+            ':', '', (offset, on-off-seq)}. See `.Line2D.set_linestyle` for a
+            complete description.
+        """
+        try:
+            dashes = [mlines._get_dash_pattern(ls)]
+        except ValueError:
+            try:
+                dashes = [mlines._get_dash_pattern(x) for x in ls]
+            except ValueError as err:
+                emsg = f'Do not know how to convert {ls!r} to dashes'
+                raise ValueError(emsg) from err
+
+        # get the list of raw 'unscaled' dash patterns
+        self._us_linestyles = dashes
+
+        # broadcast and scale the lw and dash patterns
+        self._linewidths, self._linestyles = self._bcast_lwls(
+            self._us_lw, self._us_linestyles)
+
+    @_docstring.interpd
+    def set_capstyle(self, cs):
+        """
+        Set the `.CapStyle` for the collection (for all its elements).
+
+        Parameters
+        ----------
+        cs : `.CapStyle` or %(CapStyle)s
+        """
+        self._capstyle = CapStyle(cs)
+
+    @_docstring.interpd
+    def get_capstyle(self):
+        """
+        Return the cap style for the collection (for all its elements).
+
+        Returns
+        -------
+        %(CapStyle)s or None
+        """
+        return self._capstyle.name if self._capstyle else None
+
+    @_docstring.interpd
+    def set_joinstyle(self, js):
+        """
+        Set the `.JoinStyle` for the collection (for all its elements).
+
+        Parameters
+        ----------
+        js : `.JoinStyle` or %(JoinStyle)s
+        """
+        self._joinstyle = JoinStyle(js)
+
+    @_docstring.interpd
+    def get_joinstyle(self):
+        """
+        Return the join style for the collection (for all its elements).
+
+        Returns
+        -------
+        %(JoinStyle)s or None
+        """
+        return self._joinstyle.name if self._joinstyle else None
+
+    @staticmethod
+    def _bcast_lwls(linewidths, dashes):
+        """
+        Internal helper function to broadcast + scale ls/lw
+
+        In the collection drawing code, the linewidth and linestyle are cycled
+        through as circular buffers (via ``v[i % len(v)]``).  Thus, if we are
+        going to scale the dash pattern at set time (not draw time) we need to
+        do the broadcasting now and expand both lists to be the same length.
+
+        Parameters
+        ----------
+        linewidths : list
+            line widths of collection
+        dashes : list
+            dash specification (offset, (dash pattern tuple))
+
+        Returns
+        -------
+        linewidths, dashes : list
+            Will be the same length, dashes are scaled by paired linewidth
+        """
+        if mpl.rcParams['_internal.classic_mode']:
+            return linewidths, dashes
+        # make sure they are the same length so we can zip them
+        if len(dashes) != len(linewidths):
+            l_dashes = len(dashes)
+            l_lw = len(linewidths)
+            gcd = math.gcd(l_dashes, l_lw)
+            dashes = list(dashes) * (l_lw // gcd)
+            linewidths = list(linewidths) * (l_dashes // gcd)
+
+        # scale the dash patterns
+        dashes = [mlines._scale_dashes(o, d, lw)
+                  for (o, d), lw in zip(dashes, linewidths)]
+
+        return linewidths, dashes
+
+    def get_antialiased(self):
+        """
+        Get the antialiasing state for rendering.
+
+        Returns
+        -------
+        array of bools
+        """
+        return self._antialiaseds
+
+    def set_antialiased(self, aa):
+        """
+        Set the antialiasing state for rendering.
+
+        Parameters
+        ----------
+        aa : bool or list of bools
+        """
+        if aa is None:
+            aa = self._get_default_antialiased()
+        self._antialiaseds = np.atleast_1d(np.asarray(aa, bool))
+        self.stale = True
+
+    def _get_default_antialiased(self):
+        # This may be overridden in a subclass.
+        return mpl.rcParams['patch.antialiased']
+
+    def set_color(self, c):
+        """
+        Set both the edgecolor and the facecolor.
+
+        Parameters
+        ----------
+        c : :mpltype:`color` or list of RGBA tuples
+
+        See Also
+        --------
+        Collection.set_facecolor, Collection.set_edgecolor
+            For setting the edge or face color individually.
+        """
+        self.set_facecolor(c)
+        self.set_edgecolor(c)
+
+    def _get_default_facecolor(self):
+        # This may be overridden in a subclass.
+        return mpl.rcParams['patch.facecolor']
+
+    def _set_facecolor(self, c):
+        if c is None:
+            c = self._get_default_facecolor()
+
+        self._facecolors = mcolors.to_rgba_array(c, self._alpha)
+        self.stale = True
+
+    def set_facecolor(self, c):
+        """
+        Set the facecolor(s) of the collection. *c* can be a color (all patches
+        have same color), or a sequence of colors; if it is a sequence the
+        patches will cycle through the sequence.
+
+        If *c* is 'none', the patch will not be filled.
+
+        Parameters
+        ----------
+        c : :mpltype:`color` or list of :mpltype:`color`
+        """
+        if isinstance(c, str) and c.lower() in ("none", "face"):
+            c = c.lower()
+        self._original_facecolor = c
+        self._set_facecolor(c)
+
+    def get_facecolor(self):
+        return self._facecolors
+
+    def get_edgecolor(self):
+        if cbook._str_equal(self._edgecolors, 'face'):
+            return self.get_facecolor()
+        else:
+            return self._edgecolors
+
+    def _get_default_edgecolor(self):
+        # This may be overridden in a subclass.
+        return mpl.rcParams['patch.edgecolor']
+
+    def _set_edgecolor(self, c):
+        set_hatch_color = True
+        if c is None:
+            if (mpl.rcParams['patch.force_edgecolor']
+                    or self._edge_default
+                    or cbook._str_equal(self._original_facecolor, 'none')):
+                c = self._get_default_edgecolor()
+            else:
+                c = 'none'
+                set_hatch_color = False
+        if cbook._str_lower_equal(c, 'face'):
+            self._edgecolors = 'face'
+            self.stale = True
+            return
+        self._edgecolors = mcolors.to_rgba_array(c, self._alpha)
+        if set_hatch_color and len(self._edgecolors):
+            self._hatch_color = tuple(self._edgecolors[0])
+        self.stale = True
+
+    def set_edgecolor(self, c):
+        """
+        Set the edgecolor(s) of the collection.
+
+        Parameters
+        ----------
+        c : :mpltype:`color` or list of :mpltype:`color` or 'face'
+            The collection edgecolor(s).  If a sequence, the patches cycle
+            through it.  If 'face', match the facecolor.
+        """
+        # We pass through a default value for use in LineCollection.
+        # This allows us to maintain None as the default indicator in
+        # _original_edgecolor.
+        if isinstance(c, str) and c.lower() in ("none", "face"):
+            c = c.lower()
+        self._original_edgecolor = c
+        self._set_edgecolor(c)
+
+    def set_alpha(self, alpha):
+        """
+        Set the transparency of the collection.
+
+        Parameters
+        ----------
+        alpha : float or array of float or None
+            If not None, *alpha* values must be between 0 and 1, inclusive.
+            If an array is provided, its length must match the number of
+            elements in the collection.  Masked values and nans are not
+            supported.
+        """
+        artist.Artist._set_alpha_for_array(self, alpha)
+        self._set_facecolor(self._original_facecolor)
+        self._set_edgecolor(self._original_edgecolor)
+
+    set_alpha.__doc__ = artist.Artist._set_alpha_for_array.__doc__
+
+    def get_linewidth(self):
+        return self._linewidths
+
+    def get_linestyle(self):
+        return self._linestyles
+
+    def _set_mappable_flags(self):
+        """
+        Determine whether edges and/or faces are color-mapped.
+
+        This is a helper for update_scalarmappable.
+        It sets Boolean flags '_edge_is_mapped' and '_face_is_mapped'.
+
+        Returns
+        -------
+        mapping_change : bool
+            True if either flag is True, or if a flag has changed.
+        """
+        # The flags are initialized to None to ensure this returns True
+        # the first time it is called.
+        edge0 = self._edge_is_mapped
+        face0 = self._face_is_mapped
+        # After returning, the flags must be Booleans, not None.
+        self._edge_is_mapped = False
+        self._face_is_mapped = False
+        if self._A is not None:
+            if not cbook._str_equal(self._original_facecolor, 'none'):
+                self._face_is_mapped = True
+                if cbook._str_equal(self._original_edgecolor, 'face'):
+                    self._edge_is_mapped = True
+            else:
+                if self._original_edgecolor is None:
+                    self._edge_is_mapped = True
+
+        mapped = self._face_is_mapped or self._edge_is_mapped
+        changed = (edge0 is None or face0 is None
+                   or self._edge_is_mapped != edge0
+                   or self._face_is_mapped != face0)
+        return mapped or changed
+
+    def update_scalarmappable(self):
+        """
+        Update colors from the scalar mappable array, if any.
+
+        Assign colors to edges and faces based on the array and/or
+        colors that were directly set, as appropriate.
+        """
+        if not self._set_mappable_flags():
+            return
+        # Allow possibility to call 'self.set_array(None)'.
+        if self._A is not None:
+            # QuadMesh can map 2d arrays (but pcolormesh supplies 1d array)
+            if self._A.ndim > 1 and not isinstance(self, _MeshData):
+                raise ValueError('Collections can only map rank 1 arrays')
+            if np.iterable(self._alpha):
+                if self._alpha.size != self._A.size:
+                    raise ValueError(
+                        f'Data array shape, {self._A.shape} '
+                        'is incompatible with alpha array shape, '
+                        f'{self._alpha.shape}. '
+                        'This can occur with the deprecated '
+                        'behavior of the "flat" shading option, '
+                        'in which a row and/or column of the data '
+                        'array is dropped.')
+                # pcolormesh, scatter, maybe others flatten their _A
+                self._alpha = self._alpha.reshape(self._A.shape)
+            self._mapped_colors = self.to_rgba(self._A, self._alpha)
+
+        if self._face_is_mapped:
+            self._facecolors = self._mapped_colors
+        else:
+            self._set_facecolor(self._original_facecolor)
+        if self._edge_is_mapped:
+            self._edgecolors = self._mapped_colors
+        else:
+            self._set_edgecolor(self._original_edgecolor)
+        self.stale = True
+
+    def get_fill(self):
+        """Return whether face is colored."""
+        return not cbook._str_lower_equal(self._original_facecolor, "none")
+
+    def update_from(self, other):
+        """Copy properties from other to self."""
+
+        artist.Artist.update_from(self, other)
+        self._antialiaseds = other._antialiaseds
+        self._mapped_colors = other._mapped_colors
+        self._edge_is_mapped = other._edge_is_mapped
+        self._original_edgecolor = other._original_edgecolor
+        self._edgecolors = other._edgecolors
+        self._face_is_mapped = other._face_is_mapped
+        self._original_facecolor = other._original_facecolor
+        self._facecolors = other._facecolors
+        self._linewidths = other._linewidths
+        self._linestyles = other._linestyles
+        self._us_linestyles = other._us_linestyles
+        self._pickradius = other._pickradius
+        self._hatch = other._hatch
+
+        # update_from for scalarmappable
+        self._A = other._A
+        self.norm = other.norm
+        self.cmap = other.cmap
+        self.stale = True
+
+
+class _CollectionWithSizes(Collection):
+    """
+    Base class for collections that have an array of sizes.
+    """
+    _factor = 1.0
+
+    def get_sizes(self):
+        """
+        Return the sizes ('areas') of the elements in the collection.
+
+        Returns
+        -------
+        array
+            The 'area' of each element.
+        """
+        return self._sizes
+
+    def set_sizes(self, sizes, dpi=72.0):
+        """
+        Set the sizes of each member of the collection.
+
+        Parameters
+        ----------
+        sizes : `numpy.ndarray` or None
+            The size to set for each element of the collection.  The
+            value is the 'area' of the element.
+        dpi : float, default: 72
+            The dpi of the canvas.
+        """
+        if sizes is None:
+            self._sizes = np.array([])
+            self._transforms = np.empty((0, 3, 3))
+        else:
+            self._sizes = np.asarray(sizes)
+            self._transforms = np.zeros((len(self._sizes), 3, 3))
+            scale = np.sqrt(self._sizes) * dpi / 72.0 * self._factor
+            self._transforms[:, 0, 0] = scale
+            self._transforms[:, 1, 1] = scale
+            self._transforms[:, 2, 2] = 1.0
+        self.stale = True
+
+    @artist.allow_rasterization
+    def draw(self, renderer):
+        self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
+        super().draw(renderer)
+
+
+class PathCollection(_CollectionWithSizes):
+    r"""
+    A collection of `~.path.Path`\s, as created by e.g. `~.Axes.scatter`.
+    """
+
+    def __init__(self, paths, sizes=None, **kwargs):
+        """
+        Parameters
+        ----------
+        paths : list of `.path.Path`
+            The paths that will make up the `.Collection`.
+        sizes : array-like
+            The factor by which to scale each drawn `~.path.Path`. One unit
+            squared in the Path's data space is scaled to be ``sizes**2``
+            points when rendered.
+        **kwargs
+            Forwarded to `.Collection`.
+        """
+
+        super().__init__(**kwargs)
+        self.set_paths(paths)
+        self.set_sizes(sizes)
+        self.stale = True
+
+    def get_paths(self):
+        return self._paths
+
+    def legend_elements(self, prop="colors", num="auto",
+                        fmt=None, func=lambda x: x, **kwargs):
+        """
+        Create legend handles and labels for a PathCollection.
+
+        Each legend handle is a `.Line2D` representing the Path that was drawn,
+        and each label is a string that represents the Path.
+
+        This is useful for obtaining a legend for a `~.Axes.scatter` plot;
+        e.g.::
+
+            scatter = plt.scatter([1, 2, 3],  [4, 5, 6],  c=[7, 2, 3], num=None)
+            plt.legend(*scatter.legend_elements())
+
+        creates three legend elements, one for each color with the numerical
+        values passed to *c* as the labels.
+
+        Also see the :ref:`automatedlegendcreation` example.
+
+        Parameters
+        ----------
+        prop : {"colors", "sizes"}, default: "colors"
+            If "colors", the legend handles will show the different colors of
+            the collection. If "sizes", the legend will show the different
+            sizes. To set both, use *kwargs* to directly edit the `.Line2D`
+            properties.
+        num : int, None, "auto" (default), array-like, or `~.ticker.Locator`
+            Target number of elements to create.
+            If None, use all unique elements of the mappable array. If an
+            integer, target to use *num* elements in the normed range.
+            If *"auto"*, try to determine which option better suits the nature
+            of the data.
+            The number of created elements may slightly deviate from *num* due
+            to a `~.ticker.Locator` being used to find useful locations.
+            If a list or array, use exactly those elements for the legend.
+            Finally, a `~.ticker.Locator` can be provided.
+        fmt : str, `~matplotlib.ticker.Formatter`, or None (default)
+            The format or formatter to use for the labels. If a string must be
+            a valid input for a `.StrMethodFormatter`. If None (the default),
+            use a `.ScalarFormatter`.
+        func : function, default: ``lambda x: x``
+            Function to calculate the labels.  Often the size (or color)
+            argument to `~.Axes.scatter` will have been pre-processed by the
+            user using a function ``s = f(x)`` to make the markers visible;
+            e.g. ``size = np.log10(x)``.  Providing the inverse of this
+            function here allows that pre-processing to be inverted, so that
+            the legend labels have the correct values; e.g. ``func = lambda
+            x: 10**x``.
+        **kwargs
+            Allowed keyword arguments are *color* and *size*. E.g. it may be
+            useful to set the color of the markers if *prop="sizes"* is used;
+            similarly to set the size of the markers if *prop="colors"* is
+            used. Any further parameters are passed onto the `.Line2D`
+            instance. This may be useful to e.g. specify a different
+            *markeredgecolor* or *alpha* for the legend handles.
+
+        Returns
+        -------
+        handles : list of `.Line2D`
+            Visual representation of each element of the legend.
+        labels : list of str
+            The string labels for elements of the legend.
+        """
+        handles = []
+        labels = []
+        hasarray = self.get_array() is not None
+        if fmt is None:
+            fmt = mpl.ticker.ScalarFormatter(useOffset=False, useMathText=True)
+        elif isinstance(fmt, str):
+            fmt = mpl.ticker.StrMethodFormatter(fmt)
+        fmt.create_dummy_axis()
+
+        if prop == "colors":
+            if not hasarray:
+                warnings.warn("Collection without array used. Make sure to "
+                              "specify the values to be colormapped via the "
+                              "`c` argument.")
+                return handles, labels
+            u = np.unique(self.get_array())
+            size = kwargs.pop("size", mpl.rcParams["lines.markersize"])
+        elif prop == "sizes":
+            u = np.unique(self.get_sizes())
+            color = kwargs.pop("color", "k")
+        else:
+            raise ValueError("Valid values for `prop` are 'colors' or "
+                             f"'sizes'. You supplied '{prop}' instead.")
+
+        fu = func(u)
+        fmt.axis.set_view_interval(fu.min(), fu.max())
+        fmt.axis.set_data_interval(fu.min(), fu.max())
+        if num == "auto":
+            num = 9
+            if len(u) <= num:
+                num = None
+        if num is None:
+            values = u
+            label_values = func(values)
+        else:
+            if prop == "colors":
+                arr = self.get_array()
+            elif prop == "sizes":
+                arr = self.get_sizes()
+            if isinstance(num, mpl.ticker.Locator):
+                loc = num
+            elif np.iterable(num):
+                loc = mpl.ticker.FixedLocator(num)
+            else:
+                num = int(num)
+                loc = mpl.ticker.MaxNLocator(nbins=num, min_n_ticks=num-1,
+                                             steps=[1, 2, 2.5, 3, 5, 6, 8, 10])
+            label_values = loc.tick_values(func(arr).min(), func(arr).max())
+            cond = ((label_values >= func(arr).min()) &
+                    (label_values <= func(arr).max()))
+            label_values = label_values[cond]
+            yarr = np.linspace(arr.min(), arr.max(), 256)
+            xarr = func(yarr)
+            ix = np.argsort(xarr)
+            values = np.interp(label_values, xarr[ix], yarr[ix])
+
+        kw = {"markeredgewidth": self.get_linewidths()[0],
+              "alpha": self.get_alpha(),
+              **kwargs}
+
+        for val, lab in zip(values, label_values):
+            if prop == "colors":
+                color = self.cmap(self.norm(val))
+            elif prop == "sizes":
+                size = np.sqrt(val)
+                if np.isclose(size, 0.0):
+                    continue
+            h = mlines.Line2D([0], [0], ls="", color=color, ms=size,
+                              marker=self.get_paths()[0], **kw)
+            handles.append(h)
+            if hasattr(fmt, "set_locs"):
+                fmt.set_locs(label_values)
+            l = fmt(lab)
+            labels.append(l)
+
+        return handles, labels
+
+
+class PolyCollection(_CollectionWithSizes):
+
+    def __init__(self, verts, sizes=None, *, closed=True, **kwargs):
+        """
+        Parameters
+        ----------
+        verts : list of array-like
+            The sequence of polygons [*verts0*, *verts1*, ...] where each
+            element *verts_i* defines the vertices of polygon *i* as a 2D
+            array-like of shape (M, 2).
+        sizes : array-like, default: None
+            Squared scaling factors for the polygons. The coordinates of each
+            polygon *verts_i* are multiplied by the square-root of the
+            corresponding entry in *sizes* (i.e., *sizes* specify the scaling
+            of areas). The scaling is applied before the Artist master
+            transform.
+        closed : bool, default: True
+            Whether the polygon should be closed by adding a CLOSEPOLY
+            connection at the end.
+        **kwargs
+            Forwarded to `.Collection`.
+        """
+        super().__init__(**kwargs)
+        self.set_sizes(sizes)
+        self.set_verts(verts, closed)
+        self.stale = True
+
+    def set_verts(self, verts, closed=True):
+        """
+        Set the vertices of the polygons.
+
+        Parameters
+        ----------
+        verts : list of array-like
+            The sequence of polygons [*verts0*, *verts1*, ...] where each
+            element *verts_i* defines the vertices of polygon *i* as a 2D
+            array-like of shape (M, 2).
+        closed : bool, default: True
+            Whether the polygon should be closed by adding a CLOSEPOLY
+            connection at the end.
+        """
+        self.stale = True
+        if isinstance(verts, np.ma.MaskedArray):
+            verts = verts.astype(float).filled(np.nan)
+
+        # No need to do anything fancy if the path isn't closed.
+        if not closed:
+            self._paths = [mpath.Path(xy) for xy in verts]
+            return
+
+        # Fast path for arrays
+        if isinstance(verts, np.ndarray) and len(verts.shape) == 3:
+            verts_pad = np.concatenate((verts, verts[:, :1]), axis=1)
+            # Creating the codes once is much faster than having Path do it
+            # separately each time by passing closed=True.
+            codes = np.empty(verts_pad.shape[1], dtype=mpath.Path.code_type)
+            codes[:] = mpath.Path.LINETO
+            codes[0] = mpath.Path.MOVETO
+            codes[-1] = mpath.Path.CLOSEPOLY
+            self._paths = [mpath.Path(xy, codes) for xy in verts_pad]
+            return
+
+        self._paths = []
+        for xy in verts:
+            if len(xy):
+                self._paths.append(mpath.Path._create_closed(xy))
+            else:
+                self._paths.append(mpath.Path(xy))
+
+    set_paths = set_verts
+
+    def set_verts_and_codes(self, verts, codes):
+        """Initialize vertices with path codes."""
+        if len(verts) != len(codes):
+            raise ValueError("'codes' must be a 1D list or array "
+                             "with the same length of 'verts'")
+        self._paths = [mpath.Path(xy, cds) if len(xy) else mpath.Path(xy)
+                       for xy, cds in zip(verts, codes)]
+        self.stale = True
+
+
+class FillBetweenPolyCollection(PolyCollection):
+    """
+    `.PolyCollection` that fills the area between two x- or y-curves.
+    """
+    def __init__(
+            self, t_direction, t, f1, f2, *,
+            where=None, interpolate=False, step=None, **kwargs):
+        """
+        Parameters
+        ----------
+        t_direction : {{'x', 'y'}}
+            The axes on which the variable lies.
+
+            - 'x': the curves are ``(t, f1)`` and ``(t, f2)``.
+            - 'y': the curves are ``(f1, t)`` and ``(f2, t)``.
+
+        t : array (length N)
+            The ``t_direction`` coordinates of the nodes defining the curves.
+
+        f1 : array (length N) or scalar
+            The other coordinates of the nodes defining the first curve.
+
+        f2 : array (length N) or scalar
+            The other coordinates of the nodes defining the second curve.
+
+        where : array of bool (length N), optional
+            Define *where* to exclude some {dir} regions from being filled.
+            The filled regions are defined by the coordinates ``t[where]``.
+            More precisely, fill between ``t[i]`` and ``t[i+1]`` if
+            ``where[i] and where[i+1]``.  Note that this definition implies
+            that an isolated *True* value between two *False* values in *where*
+            will not result in filling.  Both sides of the *True* position
+            remain unfilled due to the adjacent *False* values.
+
+        interpolate : bool, default: False
+            This option is only relevant if *where* is used and the two curves
+            are crossing each other.
+
+            Semantically, *where* is often used for *f1* > *f2* or
+            similar.  By default, the nodes of the polygon defining the filled
+            region will only be placed at the positions in the *t* array.
+            Such a polygon cannot describe the above semantics close to the
+            intersection.  The t-sections containing the intersection are
+            simply clipped.
+
+            Setting *interpolate* to *True* will calculate the actual
+            intersection point and extend the filled region up to this point.
+
+        step : {{'pre', 'post', 'mid'}}, optional
+            Define *step* if the filling should be a step function,
+            i.e. constant in between *t*.  The value determines where the
+            step will occur:
+
+            - 'pre': The f value is continued constantly to the left from
+              every *t* position, i.e. the interval ``(t[i-1], t[i]]`` has the
+              value ``f[i]``.
+            - 'post': The y value is continued constantly to the right from
+              every *x* position, i.e. the interval ``[t[i], t[i+1])`` has the
+              value ``f[i]``.
+            - 'mid': Steps occur half-way between the *t* positions.
+
+        **kwargs
+            Forwarded to `.PolyCollection`.
+
+        See Also
+        --------
+        .Axes.fill_between, .Axes.fill_betweenx
+        """
+        self.t_direction = t_direction
+        self._interpolate = interpolate
+        self._step = step
+        verts = self._make_verts(t, f1, f2, where)
+        super().__init__(verts, **kwargs)
+
+    @staticmethod
+    def _f_dir_from_t(t_direction):
+        """The direction that is other than `t_direction`."""
+        if t_direction == "x":
+            return "y"
+        elif t_direction == "y":
+            return "x"
+        else:
+            msg = f"t_direction must be 'x' or 'y', got {t_direction!r}"
+            raise ValueError(msg)
+
+    @property
+    def _f_direction(self):
+        """The direction that is other than `self.t_direction`."""
+        return self._f_dir_from_t(self.t_direction)
+
+    def set_data(self, t, f1, f2, *, where=None):
+        """
+        Set new values for the two bounding curves.
+
+        Parameters
+        ----------
+        t : array (length N)
+            The ``self.t_direction`` coordinates of the nodes defining the curves.
+
+        f1 : array (length N) or scalar
+            The other coordinates of the nodes defining the first curve.
+
+        f2 : array (length N) or scalar
+            The other coordinates of the nodes defining the second curve.
+
+        where : array of bool (length N), optional
+            Define *where* to exclude some {dir} regions from being filled.
+            The filled regions are defined by the coordinates ``t[where]``.
+            More precisely, fill between ``t[i]`` and ``t[i+1]`` if
+            ``where[i] and where[i+1]``.  Note that this definition implies
+            that an isolated *True* value between two *False* values in *where*
+            will not result in filling.  Both sides of the *True* position
+            remain unfilled due to the adjacent *False* values.
+
+        See Also
+        --------
+        .PolyCollection.set_verts, .Line2D.set_data
+        """
+        t, f1, f2 = self.axes._fill_between_process_units(
+            self.t_direction, self._f_direction, t, f1, f2)
+
+        verts = self._make_verts(t, f1, f2, where)
+        self.set_verts(verts)
+
+    def get_datalim(self, transData):
+        """Calculate the data limits and return them as a `.Bbox`."""
+        datalim = transforms.Bbox.null()
+        datalim.update_from_data_xy((self.get_transform() - transData).transform(
+            np.concatenate([self._bbox, [self._bbox.minpos]])))
+        return datalim
+
+    def _make_verts(self, t, f1, f2, where):
+        """
+        Make verts that can be forwarded to `.PolyCollection`.
+        """
+        self._validate_shapes(self.t_direction, self._f_direction, t, f1, f2)
+
+        where = self._get_data_mask(t, f1, f2, where)
+        t, f1, f2 = np.broadcast_arrays(np.atleast_1d(t), f1, f2, subok=True)
+
+        self._bbox = transforms.Bbox.null()
+        self._bbox.update_from_data_xy(self._fix_pts_xy_order(np.concatenate([
+            np.stack((t[where], f[where]), axis=-1) for f in (f1, f2)])))
+
+        return [
+            self._make_verts_for_region(t, f1, f2, idx0, idx1)
+            for idx0, idx1 in cbook.contiguous_regions(where)
+        ]
+
+    def _get_data_mask(self, t, f1, f2, where):
+        """
+        Return a bool array, with True at all points that should eventually be rendered.
+
+        The array is True at a point if none of the data inputs
+        *t*, *f1*, *f2* is masked and if the input *where* is true at that point.
+        """
+        if where is None:
+            where = True
+        else:
+            where = np.asarray(where, dtype=bool)
+            if where.size != t.size:
+                msg = "where size ({}) does not match {!r} size ({})".format(
+                    where.size, self.t_direction, t.size)
+                raise ValueError(msg)
+        return where & ~functools.reduce(
+            np.logical_or, map(np.ma.getmaskarray, [t, f1, f2]))
+
+    @staticmethod
+    def _validate_shapes(t_dir, f_dir, t, f1, f2):
+        """Validate that t, f1 and f2 are 1-dimensional and have the same length."""
+        names = (d + s for d, s in zip((t_dir, f_dir, f_dir), ("", "1", "2")))
+        for name, array in zip(names, [t, f1, f2]):
+            if array.ndim > 1:
+                raise ValueError(f"{name!r} is not 1-dimensional")
+            if t.size > 1 and array.size > 1 and t.size != array.size:
+                msg = "{!r} has size {}, but {!r} has an unequal size of {}".format(
+                    t_dir, t.size, name, array.size)
+                raise ValueError(msg)
+
+    def _make_verts_for_region(self, t, f1, f2, idx0, idx1):
+        """
+        Make ``verts`` for a contiguous region between ``idx0`` and ``idx1``, taking
+        into account ``step`` and ``interpolate``.
+        """
+        t_slice = t[idx0:idx1]
+        f1_slice = f1[idx0:idx1]
+        f2_slice = f2[idx0:idx1]
+        if self._step is not None:
+            step_func = cbook.STEP_LOOKUP_MAP["steps-" + self._step]
+            t_slice, f1_slice, f2_slice = step_func(t_slice, f1_slice, f2_slice)
+
+        if self._interpolate:
+            start = self._get_interpolating_points(t, f1, f2, idx0)
+            end = self._get_interpolating_points(t, f1, f2, idx1)
+        else:
+            # Handle scalar f2 (e.g. 0): the fill should go all
+            # the way down to 0 even if none of the dep1 sample points do.
+            start = t_slice[0], f2_slice[0]
+            end = t_slice[-1], f2_slice[-1]
+
+        pts = np.concatenate((
+            np.asarray([start]),
+            np.stack((t_slice, f1_slice), axis=-1),
+            np.asarray([end]),
+            np.stack((t_slice, f2_slice), axis=-1)[::-1]))
+
+        return self._fix_pts_xy_order(pts)
+
+    @classmethod
+    def _get_interpolating_points(cls, t, f1, f2, idx):
+        """Calculate interpolating points."""
+        im1 = max(idx - 1, 0)
+        t_values = t[im1:idx+1]
+        diff_values = f1[im1:idx+1] - f2[im1:idx+1]
+        f1_values = f1[im1:idx+1]
+
+        if len(diff_values) == 2:
+            if np.ma.is_masked(diff_values[1]):
+                return t[im1], f1[im1]
+            elif np.ma.is_masked(diff_values[0]):
+                return t[idx], f1[idx]
+
+        diff_root_t = cls._get_diff_root(0, diff_values, t_values)
+        diff_root_f = cls._get_diff_root(diff_root_t, t_values, f1_values)
+        return diff_root_t, diff_root_f
+
+    @staticmethod
+    def _get_diff_root(x, xp, fp):
+        """Calculate diff root."""
+        order = xp.argsort()
+        return np.interp(x, xp[order], fp[order])
+
+    def _fix_pts_xy_order(self, pts):
+        """
+        Fix pts calculation results with `self.t_direction`.
+
+        In the workflow, it is assumed that `self.t_direction` is 'x'. If this
+        is not true, we need to exchange the coordinates.
+        """
+        return pts[:, ::-1] if self.t_direction == "y" else pts
+
+
+class RegularPolyCollection(_CollectionWithSizes):
+    """A collection of n-sided regular polygons."""
+
+    _path_generator = mpath.Path.unit_regular_polygon
+    _factor = np.pi ** (-1/2)
+
+    def __init__(self,
+                 numsides,
+                 *,
+                 rotation=0,
+                 sizes=(1,),
+                 **kwargs):
+        """
+        Parameters
+        ----------
+        numsides : int
+            The number of sides of the polygon.
+        rotation : float
+            The rotation of the polygon in radians.
+        sizes : tuple of float
+            The area of the circle circumscribing the polygon in points^2.
+        **kwargs
+            Forwarded to `.Collection`.
+
+        Examples
+        --------
+        See :doc:`/gallery/event_handling/lasso_demo` for a complete example::
+
+            offsets = np.random.rand(20, 2)
+            facecolors = [cm.jet(x) for x in np.random.rand(20)]
+
+            collection = RegularPolyCollection(
+                numsides=5, # a pentagon
+                rotation=0, sizes=(50,),
+                facecolors=facecolors,
+                edgecolors=("black",),
+                linewidths=(1,),
+                offsets=offsets,
+                offset_transform=ax.transData,
+                )
+        """
+        super().__init__(**kwargs)
+        self.set_sizes(sizes)
+        self._numsides = numsides
+        self._paths = [self._path_generator(numsides)]
+        self._rotation = rotation
+        self.set_transform(transforms.IdentityTransform())
+
+    def get_numsides(self):
+        return self._numsides
+
+    def get_rotation(self):
+        return self._rotation
+
+    @artist.allow_rasterization
+    def draw(self, renderer):
+        self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
+        self._transforms = [
+            transforms.Affine2D(x).rotate(-self._rotation).get_matrix()
+            for x in self._transforms
+        ]
+        # Explicitly not super().draw, because set_sizes must be called before
+        # updating self._transforms.
+        Collection.draw(self, renderer)
+
+
+class StarPolygonCollection(RegularPolyCollection):
+    """Draw a collection of regular stars with *numsides* points."""
+    _path_generator = mpath.Path.unit_regular_star
+
+
+class AsteriskPolygonCollection(RegularPolyCollection):
+    """Draw a collection of regular asterisks with *numsides* points."""
+    _path_generator = mpath.Path.unit_regular_asterisk
+
+
+class LineCollection(Collection):
+    r"""
+    Represents a sequence of `.Line2D`\s that should be drawn together.
+
+    This class extends `.Collection` to represent a sequence of
+    `.Line2D`\s instead of just a sequence of `.Patch`\s.
+    Just as in `.Collection`, each property of a *LineCollection* may be either
+    a single value or a list of values. This list is then used cyclically for
+    each element of the LineCollection, so the property of the ``i``\th element
+    of the collection is::
+
+      prop[i % len(prop)]
+
+    The properties of each member of a *LineCollection* default to their values
+    in :rc:`lines.*` instead of :rc:`patch.*`, and the property *colors* is
+    added in place of *edgecolors*.
+    """
+
+    _edge_default = True
+
+    def __init__(self, segments,  # Can be None.
+                 *,
+                 zorder=2,        # Collection.zorder is 1
+                 **kwargs
+                 ):
+        """
+        Parameters
+        ----------
+        segments : list of (N, 2) array-like
+            A sequence ``[line0, line1, ...]`` where each line is a (N, 2)-shape
+            array-like containing points::
+
+                line0 = [(x0, y0), (x1, y1), ...]
+
+            Each line can contain a different number of points.
+        linewidths : float or list of float, default: :rc:`lines.linewidth`
+            The width of each line in points.
+        colors : :mpltype:`color` or list of color, default: :rc:`lines.color`
+            A sequence of RGBA tuples (e.g., arbitrary color strings, etc, not
+            allowed).
+        antialiaseds : bool or list of bool, default: :rc:`lines.antialiased`
+            Whether to use antialiasing for each line.
+        zorder : float, default: 2
+            zorder of the lines once drawn.
+
+        facecolors : :mpltype:`color` or list of :mpltype:`color`, default: 'none'
+            When setting *facecolors*, each line is interpreted as a boundary
+            for an area, implicitly closing the path from the last point to the
+            first point. The enclosed area is filled with *facecolor*.
+            In order to manually specify what should count as the "interior" of
+            each line, please use `.PathCollection` instead, where the
+            "interior" can be specified by appropriate usage of
+            `~.path.Path.CLOSEPOLY`.
+
+        **kwargs
+            Forwarded to `.Collection`.
+        """
+        # Unfortunately, mplot3d needs this explicit setting of 'facecolors'.
+        kwargs.setdefault('facecolors', 'none')
+        super().__init__(
+            zorder=zorder,
+            **kwargs)
+        self.set_segments(segments)
+
+    def set_segments(self, segments):
+        if segments is None:
+            return
+
+        self._paths = [mpath.Path(seg) if isinstance(seg, np.ma.MaskedArray)
+                       else mpath.Path(np.asarray(seg, float))
+                       for seg in segments]
+        self.stale = True
+
+    set_verts = set_segments  # for compatibility with PolyCollection
+    set_paths = set_segments
+
+    def get_segments(self):
+        """
+        Returns
+        -------
+        list
+            List of segments in the LineCollection. Each list item contains an
+            array of vertices.
+        """
+        segments = []
+
+        for path in self._paths:
+            vertices = [
+                vertex
+                for vertex, _
+                # Never simplify here, we want to get the data-space values
+                # back and there in no way to know the "right" simplification
+                # threshold so never try.
+                in path.iter_segments(simplify=False)
+            ]
+            vertices = np.asarray(vertices)
+            segments.append(vertices)
+
+        return segments
+
+    def _get_default_linewidth(self):
+        return mpl.rcParams['lines.linewidth']
+
+    def _get_default_antialiased(self):
+        return mpl.rcParams['lines.antialiased']
+
+    def _get_default_edgecolor(self):
+        return mpl.rcParams['lines.color']
+
+    def _get_default_facecolor(self):
+        return 'none'
+
+    def set_alpha(self, alpha):
+        # docstring inherited
+        super().set_alpha(alpha)
+        if self._gapcolor is not None:
+            self.set_gapcolor(self._original_gapcolor)
+
+    def set_color(self, c):
+        """
+        Set the edgecolor(s) of the LineCollection.
+
+        Parameters
+        ----------
+        c : :mpltype:`color` or list of :mpltype:`color`
+            Single color (all lines have same color), or a
+            sequence of RGBA tuples; if it is a sequence the lines will
+            cycle through the sequence.
+        """
+        self.set_edgecolor(c)
+
+    set_colors = set_color
+
+    def get_color(self):
+        return self._edgecolors
+
+    get_colors = get_color  # for compatibility with old versions
+
+    def set_gapcolor(self, gapcolor):
+        """
+        Set a color to fill the gaps in the dashed line style.
+
+        .. note::
+
+            Striped lines are created by drawing two interleaved dashed lines.
+            There can be overlaps between those two, which may result in
+            artifacts when using transparency.
+
+            This functionality is experimental and may change.
+
+        Parameters
+        ----------
+        gapcolor : :mpltype:`color` or list of :mpltype:`color` or None
+            The color with which to fill the gaps. If None, the gaps are
+            unfilled.
+        """
+        self._original_gapcolor = gapcolor
+        self._set_gapcolor(gapcolor)
+
+    def _set_gapcolor(self, gapcolor):
+        if gapcolor is not None:
+            gapcolor = mcolors.to_rgba_array(gapcolor, self._alpha)
+        self._gapcolor = gapcolor
+        self.stale = True
+
+    def get_gapcolor(self):
+        return self._gapcolor
+
+    def _get_inverse_paths_linestyles(self):
+        """
+        Returns the path and pattern for the gaps in the non-solid lines.
+
+        This path and pattern is the inverse of the path and pattern used to
+        construct the non-solid lines. For solid lines, we set the inverse path
+        to nans to prevent drawing an inverse line.
+        """
+        path_patterns = [
+            (mpath.Path(np.full((1, 2), np.nan)), ls)
+            if ls == (0, None) else
+            (path, mlines._get_inverse_dash_pattern(*ls))
+            for (path, ls) in
+            zip(self._paths, itertools.cycle(self._linestyles))]
+
+        return zip(*path_patterns)
+
+
+class EventCollection(LineCollection):
+    """
+    A collection of locations along a single axis at which an "event" occurred.
+
+    The events are given by a 1-dimensional array. They do not have an
+    amplitude and are displayed as parallel lines.
+    """
+
+    _edge_default = True
+
+    def __init__(self,
+                 positions,  # Cannot be None.
+                 orientation='horizontal',
+                 *,
+                 lineoffset=0,
+                 linelength=1,
+                 linewidth=None,
+                 color=None,
+                 linestyle='solid',
+                 antialiased=None,
+                 **kwargs
+                 ):
+        """
+        Parameters
+        ----------
+        positions : 1D array-like
+            Each value is an event.
+        orientation : {'horizontal', 'vertical'}, default: 'horizontal'
+            The sequence of events is plotted along this direction.
+            The marker lines of the single events are along the orthogonal
+            direction.
+        lineoffset : float, default: 0
+            The offset of the center of the markers from the origin, in the
+            direction orthogonal to *orientation*.
+        linelength : float, default: 1
+            The total height of the marker (i.e. the marker stretches from
+            ``lineoffset - linelength/2`` to ``lineoffset + linelength/2``).
+        linewidth : float or list thereof, default: :rc:`lines.linewidth`
+            The line width of the event lines, in points.
+        color : :mpltype:`color` or list of :mpltype:`color`, default: :rc:`lines.color`
+            The color of the event lines.
+        linestyle : str or tuple or list thereof, default: 'solid'
+            Valid strings are ['solid', 'dashed', 'dashdot', 'dotted',
+            '-', '--', '-.', ':']. Dash tuples should be of the form::
+
+                (offset, onoffseq),
+
+            where *onoffseq* is an even length tuple of on and off ink
+            in points.
+        antialiased : bool or list thereof, default: :rc:`lines.antialiased`
+            Whether to use antialiasing for drawing the lines.
+        **kwargs
+            Forwarded to `.LineCollection`.
+
+        Examples
+        --------
+        .. plot:: gallery/lines_bars_and_markers/eventcollection_demo.py
+        """
+        super().__init__([],
+                         linewidths=linewidth, linestyles=linestyle,
+                         colors=color, antialiaseds=antialiased,
+                         **kwargs)
+        self._is_horizontal = True  # Initial value, may be switched below.
+        self._linelength = linelength
+        self._lineoffset = lineoffset
+        self.set_orientation(orientation)
+        self.set_positions(positions)
+
+    def get_positions(self):
+        """
+        Return an array containing the floating-point values of the positions.
+        """
+        pos = 0 if self.is_horizontal() else 1
+        return [segment[0, pos] for segment in self.get_segments()]
+
+    def set_positions(self, positions):
+        """Set the positions of the events."""
+        if positions is None:
+            positions = []
+        if np.ndim(positions) != 1:
+            raise ValueError('positions must be one-dimensional')
+        lineoffset = self.get_lineoffset()
+        linelength = self.get_linelength()
+        pos_idx = 0 if self.is_horizontal() else 1
+        segments = np.empty((len(positions), 2, 2))
+        segments[:, :, pos_idx] = np.sort(positions)[:, None]
+        segments[:, 0, 1 - pos_idx] = lineoffset + linelength / 2
+        segments[:, 1, 1 - pos_idx] = lineoffset - linelength / 2
+        self.set_segments(segments)
+
+    def add_positions(self, position):
+        """Add one or more events at the specified positions."""
+        if position is None or (hasattr(position, 'len') and
+                                len(position) == 0):
+            return
+        positions = self.get_positions()
+        positions = np.hstack([positions, np.asanyarray(position)])
+        self.set_positions(positions)
+    extend_positions = append_positions = add_positions
+
+    def is_horizontal(self):
+        """True if the eventcollection is horizontal, False if vertical."""
+        return self._is_horizontal
+
+    def get_orientation(self):
+        """
+        Return the orientation of the event line ('horizontal' or 'vertical').
+        """
+        return 'horizontal' if self.is_horizontal() else 'vertical'
+
+    def switch_orientation(self):
+        """
+        Switch the orientation of the event line, either from vertical to
+        horizontal or vice versus.
+        """
+        segments = self.get_segments()
+        for i, segment in enumerate(segments):
+            segments[i] = np.fliplr(segment)
+        self.set_segments(segments)
+        self._is_horizontal = not self.is_horizontal()
+        self.stale = True
+
+    def set_orientation(self, orientation):
+        """
+        Set the orientation of the event line.
+
+        Parameters
+        ----------
+        orientation : {'horizontal', 'vertical'}
+        """
+        is_horizontal = _api.check_getitem(
+            {"horizontal": True, "vertical": False},
+            orientation=orientation)
+        if is_horizontal == self.is_horizontal():
+            return
+        self.switch_orientation()
+
+    def get_linelength(self):
+        """Return the length of the lines used to mark each event."""
+        return self._linelength
+
+    def set_linelength(self, linelength):
+        """Set the length of the lines used to mark each event."""
+        if linelength == self.get_linelength():
+            return
+        lineoffset = self.get_lineoffset()
+        segments = self.get_segments()
+        pos = 1 if self.is_horizontal() else 0
+        for segment in segments:
+            segment[0, pos] = lineoffset + linelength / 2.
+            segment[1, pos] = lineoffset - linelength / 2.
+        self.set_segments(segments)
+        self._linelength = linelength
+
+    def get_lineoffset(self):
+        """Return the offset of the lines used to mark each event."""
+        return self._lineoffset
+
+    def set_lineoffset(self, lineoffset):
+        """Set the offset of the lines used to mark each event."""
+        if lineoffset == self.get_lineoffset():
+            return
+        linelength = self.get_linelength()
+        segments = self.get_segments()
+        pos = 1 if self.is_horizontal() else 0
+        for segment in segments:
+            segment[0, pos] = lineoffset + linelength / 2.
+            segment[1, pos] = lineoffset - linelength / 2.
+        self.set_segments(segments)
+        self._lineoffset = lineoffset
+
+    def get_linewidth(self):
+        """Get the width of the lines used to mark each event."""
+        return super().get_linewidth()[0]
+
+    def get_linewidths(self):
+        return super().get_linewidth()
+
+    def get_color(self):
+        """Return the color of the lines used to mark each event."""
+        return self.get_colors()[0]
+
+
+class CircleCollection(_CollectionWithSizes):
+    """A collection of circles, drawn using splines."""
+
+    _factor = np.pi ** (-1/2)
+
+    def __init__(self, sizes, **kwargs):
+        """
+        Parameters
+        ----------
+        sizes : float or array-like
+            The area of each circle in points^2.
+        **kwargs
+            Forwarded to `.Collection`.
+        """
+        super().__init__(**kwargs)
+        self.set_sizes(sizes)
+        self.set_transform(transforms.IdentityTransform())
+        self._paths = [mpath.Path.unit_circle()]
+
+
+class EllipseCollection(Collection):
+    """A collection of ellipses, drawn using splines."""
+
+    def __init__(self, widths, heights, angles, *, units='points', **kwargs):
+        """
+        Parameters
+        ----------
+        widths : array-like
+            The lengths of the first axes (e.g., major axis lengths).
+        heights : array-like
+            The lengths of second axes.
+        angles : array-like
+            The angles of the first axes, degrees CCW from the x-axis.
+        units : {'points', 'inches', 'dots', 'width', 'height', 'x', 'y', 'xy'}
+            The units in which majors and minors are given; 'width' and
+            'height' refer to the dimensions of the axes, while 'x' and 'y'
+            refer to the *offsets* data units. 'xy' differs from all others in
+            that the angle as plotted varies with the aspect ratio, and equals
+            the specified angle only when the aspect ratio is unity.  Hence
+            it behaves the same as the `~.patches.Ellipse` with
+            ``axes.transData`` as its transform.
+        **kwargs
+            Forwarded to `Collection`.
+        """
+        super().__init__(**kwargs)
+        self.set_widths(widths)
+        self.set_heights(heights)
+        self.set_angles(angles)
+        self._units = units
+        self.set_transform(transforms.IdentityTransform())
+        self._transforms = np.empty((0, 3, 3))
+        self._paths = [mpath.Path.unit_circle()]
+
+    def _set_transforms(self):
+        """Calculate transforms immediately before drawing."""
+
+        ax = self.axes
+        fig = self.get_figure(root=False)
+
+        if self._units == 'xy':
+            sc = 1
+        elif self._units == 'x':
+            sc = ax.bbox.width / ax.viewLim.width
+        elif self._units == 'y':
+            sc = ax.bbox.height / ax.viewLim.height
+        elif self._units == 'inches':
+            sc = fig.dpi
+        elif self._units == 'points':
+            sc = fig.dpi / 72.0
+        elif self._units == 'width':
+            sc = ax.bbox.width
+        elif self._units == 'height':
+            sc = ax.bbox.height
+        elif self._units == 'dots':
+            sc = 1.0
+        else:
+            raise ValueError(f'Unrecognized units: {self._units!r}')
+
+        self._transforms = np.zeros((len(self._widths), 3, 3))
+        widths = self._widths * sc
+        heights = self._heights * sc
+        sin_angle = np.sin(self._angles)
+        cos_angle = np.cos(self._angles)
+        self._transforms[:, 0, 0] = widths * cos_angle
+        self._transforms[:, 0, 1] = heights * -sin_angle
+        self._transforms[:, 1, 0] = widths * sin_angle
+        self._transforms[:, 1, 1] = heights * cos_angle
+        self._transforms[:, 2, 2] = 1.0
+
+        _affine = transforms.Affine2D
+        if self._units == 'xy':
+            m = ax.transData.get_affine().get_matrix().copy()
+            m[:2, 2:] = 0
+            self.set_transform(_affine(m))
+
+    def set_widths(self, widths):
+        """Set the lengths of the first axes (e.g., major axis)."""
+        self._widths = 0.5 * np.asarray(widths).ravel()
+        self.stale = True
+
+    def set_heights(self, heights):
+        """Set the lengths of second axes (e.g., minor axes)."""
+        self._heights = 0.5 * np.asarray(heights).ravel()
+        self.stale = True
+
+    def set_angles(self, angles):
+        """Set the angles of the first axes, degrees CCW from the x-axis."""
+        self._angles = np.deg2rad(angles).ravel()
+        self.stale = True
+
+    def get_widths(self):
+        """Get the lengths of the first axes (e.g., major axis)."""
+        return self._widths * 2
+
+    def get_heights(self):
+        """Set the lengths of second axes (e.g., minor axes)."""
+        return self._heights * 2
+
+    def get_angles(self):
+        """Get the angles of the first axes, degrees CCW from the x-axis."""
+        return np.rad2deg(self._angles)
+
+    @artist.allow_rasterization
+    def draw(self, renderer):
+        self._set_transforms()
+        super().draw(renderer)
+
+
+class PatchCollection(Collection):
+    """
+    A generic collection of patches.
+
+    PatchCollection draws faster than a large number of equivalent individual
+    Patches. It also makes it easier to assign a colormap to a heterogeneous
+    collection of patches.
+    """
+
+    def __init__(self, patches, *, match_original=False, **kwargs):
+        """
+        Parameters
+        ----------
+        patches : list of `.Patch`
+            A sequence of Patch objects.  This list may include
+            a heterogeneous assortment of different patch types.
+
+        match_original : bool, default: False
+            If True, use the colors and linewidths of the original
+            patches.  If False, new colors may be assigned by
+            providing the standard collection arguments, facecolor,
+            edgecolor, linewidths, norm or cmap.
+
+        **kwargs
+            All other parameters are forwarded to `.Collection`.
+
+            If any of *edgecolors*, *facecolors*, *linewidths*, *antialiaseds*
+            are None, they default to their `.rcParams` patch setting, in
+            sequence form.
+
+        Notes
+        -----
+        The use of `~matplotlib.cm.ScalarMappable` functionality is optional.
+        If the `~matplotlib.cm.ScalarMappable` matrix ``_A`` has been set (via
+        a call to `~.ScalarMappable.set_array`), at draw time a call to scalar
+        mappable will be made to set the face colors.
+        """
+
+        if match_original:
+            def determine_facecolor(patch):
+                if patch.get_fill():
+                    return patch.get_facecolor()
+                return [0, 0, 0, 0]
+
+            kwargs['facecolors'] = [determine_facecolor(p) for p in patches]
+            kwargs['edgecolors'] = [p.get_edgecolor() for p in patches]
+            kwargs['linewidths'] = [p.get_linewidth() for p in patches]
+            kwargs['linestyles'] = [p.get_linestyle() for p in patches]
+            kwargs['antialiaseds'] = [p.get_antialiased() for p in patches]
+
+        super().__init__(**kwargs)
+
+        self.set_paths(patches)
+
+    def set_paths(self, patches):
+        paths = [p.get_transform().transform_path(p.get_path())
+                 for p in patches]
+        self._paths = paths
+
+
+class TriMesh(Collection):
+    """
+    Class for the efficient drawing of a triangular mesh using Gouraud shading.
+
+    A triangular mesh is a `~matplotlib.tri.Triangulation` object.
+    """
+    def __init__(self, triangulation, **kwargs):
+        super().__init__(**kwargs)
+        self._triangulation = triangulation
+        self._shading = 'gouraud'
+
+        self._bbox = transforms.Bbox.unit()
+
+        # Unfortunately this requires a copy, unless Triangulation
+        # was rewritten.
+        xy = np.hstack((triangulation.x.reshape(-1, 1),
+                        triangulation.y.reshape(-1, 1)))
+        self._bbox.update_from_data_xy(xy)
+
+    def get_paths(self):
+        if self._paths is None:
+            self.set_paths()
+        return self._paths
+
+    def set_paths(self):
+        self._paths = self.convert_mesh_to_paths(self._triangulation)
+
+    @staticmethod
+    def convert_mesh_to_paths(tri):
+        """
+        Convert a given mesh into a sequence of `.Path` objects.
+
+        This function is primarily of use to implementers of backends that do
+        not directly support meshes.
+        """
+        triangles = tri.get_masked_triangles()
+        verts = np.stack((tri.x[triangles], tri.y[triangles]), axis=-1)
+        return [mpath.Path(x) for x in verts]
+
+    @artist.allow_rasterization
+    def draw(self, renderer):
+        if not self.get_visible():
+            return
+        renderer.open_group(self.__class__.__name__, gid=self.get_gid())
+        transform = self.get_transform()
+
+        # Get a list of triangles and the color at each vertex.
+        tri = self._triangulation
+        triangles = tri.get_masked_triangles()
+
+        verts = np.stack((tri.x[triangles], tri.y[triangles]), axis=-1)
+
+        self.update_scalarmappable()
+        colors = self._facecolors[triangles]
+
+        gc = renderer.new_gc()
+        self._set_gc_clip(gc)
+        gc.set_linewidth(self.get_linewidth()[0])
+        renderer.draw_gouraud_triangles(gc, verts, colors, transform.frozen())
+        gc.restore()
+        renderer.close_group(self.__class__.__name__)
+
+
+class _MeshData:
+    r"""
+    Class for managing the two dimensional coordinates of Quadrilateral meshes
+    and the associated data with them. This class is a mixin and is intended to
+    be used with another collection that will implement the draw separately.
+
+    A quadrilateral mesh is a grid of M by N adjacent quadrilaterals that are
+    defined via a (M+1, N+1) grid of vertices. The quadrilateral (m, n) is
+    defined by the vertices ::
+
+               (m+1, n) ----------- (m+1, n+1)
+                  /                   /
+                 /                 /
+                /               /
+            (m, n) -------- (m, n+1)
+
+    The mesh need not be regular and the polygons need not be convex.
+
+    Parameters
+    ----------
+    coordinates : (M+1, N+1, 2) array-like
+        The vertices. ``coordinates[m, n]`` specifies the (x, y) coordinates
+        of vertex (m, n).
+
+    shading : {'flat', 'gouraud'}, default: 'flat'
+    """
+    def __init__(self, coordinates, *, shading='flat'):
+        _api.check_shape((None, None, 2), coordinates=coordinates)
+        self._coordinates = coordinates
+        self._shading = shading
+
+    def set_array(self, A):
+        """
+        Set the data values.
+
+        Parameters
+        ----------
+        A : array-like
+            The mesh data. Supported array shapes are:
+
+            - (M, N) or (M*N,): a mesh with scalar data. The values are mapped
+              to colors using normalization and a colormap. See parameters
+              *norm*, *cmap*, *vmin*, *vmax*.
+            - (M, N, 3): an image with RGB values (0-1 float or 0-255 int).
+            - (M, N, 4): an image with RGBA values (0-1 float or 0-255 int),
+              i.e. including transparency.
+
+            If the values are provided as a 2D grid, the shape must match the
+            coordinates grid. If the values are 1D, they are reshaped to 2D.
+            M, N follow from the coordinates grid, where the coordinates grid
+            shape is (M, N) for 'gouraud' *shading* and (M+1, N+1) for 'flat'
+            shading.
+        """
+        height, width = self._coordinates.shape[0:-1]
+        if self._shading == 'flat':
+            h, w = height - 1, width - 1
+        else:
+            h, w = height, width
+        ok_shapes = [(h, w, 3), (h, w, 4), (h, w), (h * w,)]
+        if A is not None:
+            shape = np.shape(A)
+            if shape not in ok_shapes:
+                raise ValueError(
+                    f"For X ({width}) and Y ({height}) with {self._shading} "
+                    f"shading, A should have shape "
+                    f"{' or '.join(map(str, ok_shapes))}, not {A.shape}")
+        return super().set_array(A)
+
+    def get_coordinates(self):
+        """
+        Return the vertices of the mesh as an (M+1, N+1, 2) array.
+
+        M, N are the number of quadrilaterals in the rows / columns of the
+        mesh, corresponding to (M+1, N+1) vertices.
+        The last dimension specifies the components (x, y).
+        """
+        return self._coordinates
+
+    def get_edgecolor(self):
+        # docstring inherited
+        # Note that we want to return an array of shape (N*M, 4)
+        # a flattened RGBA collection
+        return super().get_edgecolor().reshape(-1, 4)
+
+    def get_facecolor(self):
+        # docstring inherited
+        # Note that we want to return an array of shape (N*M, 4)
+        # a flattened RGBA collection
+        return super().get_facecolor().reshape(-1, 4)
+
+    @staticmethod
+    def _convert_mesh_to_paths(coordinates):
+        """
+        Convert a given mesh into a sequence of `.Path` objects.
+
+        This function is primarily of use to implementers of backends that do
+        not directly support quadmeshes.
+        """
+        if isinstance(coordinates, np.ma.MaskedArray):
+            c = coordinates.data
+        else:
+            c = coordinates
+        points = np.concatenate([
+            c[:-1, :-1],
+            c[:-1, 1:],
+            c[1:, 1:],
+            c[1:, :-1],
+            c[:-1, :-1]
+        ], axis=2).reshape((-1, 5, 2))
+        return [mpath.Path(x) for x in points]
+
+    def _convert_mesh_to_triangles(self, coordinates):
+        """
+        Convert a given mesh into a sequence of triangles, each point
+        with its own color.  The result can be used to construct a call to
+        `~.RendererBase.draw_gouraud_triangles`.
+        """
+        if isinstance(coordinates, np.ma.MaskedArray):
+            p = coordinates.data
+        else:
+            p = coordinates
+
+        p_a = p[:-1, :-1]
+        p_b = p[:-1, 1:]
+        p_c = p[1:, 1:]
+        p_d = p[1:, :-1]
+        p_center = (p_a + p_b + p_c + p_d) / 4.0
+        triangles = np.concatenate([
+            p_a, p_b, p_center,
+            p_b, p_c, p_center,
+            p_c, p_d, p_center,
+            p_d, p_a, p_center,
+        ], axis=2).reshape((-1, 3, 2))
+
+        c = self.get_facecolor().reshape((*coordinates.shape[:2], 4))
+        z = self.get_array()
+        mask = z.mask if np.ma.is_masked(z) else None
+        if mask is not None:
+            c[mask, 3] = np.nan
+        c_a = c[:-1, :-1]
+        c_b = c[:-1, 1:]
+        c_c = c[1:, 1:]
+        c_d = c[1:, :-1]
+        c_center = (c_a + c_b + c_c + c_d) / 4.0
+        colors = np.concatenate([
+            c_a, c_b, c_center,
+            c_b, c_c, c_center,
+            c_c, c_d, c_center,
+            c_d, c_a, c_center,
+        ], axis=2).reshape((-1, 3, 4))
+        tmask = np.isnan(colors[..., 2, 3])
+        return triangles[~tmask], colors[~tmask]
+
+
+class QuadMesh(_MeshData, Collection):
+    r"""
+    Class for the efficient drawing of a quadrilateral mesh.
+
+    A quadrilateral mesh is a grid of M by N adjacent quadrilaterals that are
+    defined via a (M+1, N+1) grid of vertices. The quadrilateral (m, n) is
+    defined by the vertices ::
+
+               (m+1, n) ----------- (m+1, n+1)
+                  /                   /
+                 /                 /
+                /               /
+            (m, n) -------- (m, n+1)
+
+    The mesh need not be regular and the polygons need not be convex.
+
+    Parameters
+    ----------
+    coordinates : (M+1, N+1, 2) array-like
+        The vertices. ``coordinates[m, n]`` specifies the (x, y) coordinates
+        of vertex (m, n).
+
+    antialiased : bool, default: True
+
+    shading : {'flat', 'gouraud'}, default: 'flat'
+
+    Notes
+    -----
+    Unlike other `.Collection`\s, the default *pickradius* of `.QuadMesh` is 0,
+    i.e. `~.Artist.contains` checks whether the test point is within any of the
+    mesh quadrilaterals.
+
+    """
+
+    def __init__(self, coordinates, *, antialiased=True, shading='flat',
+                 **kwargs):
+        kwargs.setdefault("pickradius", 0)
+        super().__init__(coordinates=coordinates, shading=shading)
+        Collection.__init__(self, **kwargs)
+
+        self._antialiased = antialiased
+        self._bbox = transforms.Bbox.unit()
+        self._bbox.update_from_data_xy(self._coordinates.reshape(-1, 2))
+        self.set_mouseover(False)
+
+    def get_paths(self):
+        if self._paths is None:
+            self.set_paths()
+        return self._paths
+
+    def set_paths(self):
+        self._paths = self._convert_mesh_to_paths(self._coordinates)
+        self.stale = True
+
+    def get_datalim(self, transData):
+        return (self.get_transform() - transData).transform_bbox(self._bbox)
+
+    @artist.allow_rasterization
+    def draw(self, renderer):
+        if not self.get_visible():
+            return
+        renderer.open_group(self.__class__.__name__, self.get_gid())
+        transform = self.get_transform()
+        offset_trf = self.get_offset_transform()
+        offsets = self.get_offsets()
+
+        if self.have_units():
+            xs = self.convert_xunits(offsets[:, 0])
+            ys = self.convert_yunits(offsets[:, 1])
+            offsets = np.column_stack([xs, ys])
+
+        self.update_scalarmappable()
+
+        if not transform.is_affine:
+            coordinates = self._coordinates.reshape((-1, 2))
+            coordinates = transform.transform(coordinates)
+            coordinates = coordinates.reshape(self._coordinates.shape)
+            transform = transforms.IdentityTransform()
+        else:
+            coordinates = self._coordinates
+
+        if not offset_trf.is_affine:
+            offsets = offset_trf.transform_non_affine(offsets)
+            offset_trf = offset_trf.get_affine()
+
+        gc = renderer.new_gc()
+        gc.set_snap(self.get_snap())
+        self._set_gc_clip(gc)
+        gc.set_linewidth(self.get_linewidth()[0])
+
+        if self._shading == 'gouraud':
+            triangles, colors = self._convert_mesh_to_triangles(coordinates)
+            renderer.draw_gouraud_triangles(
+                gc, triangles, colors, transform.frozen())
+        else:
+            renderer.draw_quad_mesh(
+                gc, transform.frozen(),
+                coordinates.shape[1] - 1, coordinates.shape[0] - 1,
+                coordinates, offsets, offset_trf,
+                # Backends expect flattened rgba arrays (n*m, 4) for fc and ec
+                self.get_facecolor().reshape((-1, 4)),
+                self._antialiased, self.get_edgecolors().reshape((-1, 4)))
+        gc.restore()
+        renderer.close_group(self.__class__.__name__)
+        self.stale = False
+
+    def get_cursor_data(self, event):
+        contained, info = self.contains(event)
+        if contained and self.get_array() is not None:
+            return self.get_array().ravel()[info["ind"]]
+        return None
+
+
+class PolyQuadMesh(_MeshData, PolyCollection):
+    """
+    Class for drawing a quadrilateral mesh as individual Polygons.
+
+    A quadrilateral mesh is a grid of M by N adjacent quadrilaterals that are
+    defined via a (M+1, N+1) grid of vertices. The quadrilateral (m, n) is
+    defined by the vertices ::
+
+               (m+1, n) ----------- (m+1, n+1)
+                  /                   /
+                 /                 /
+                /               /
+            (m, n) -------- (m, n+1)
+
+    The mesh need not be regular and the polygons need not be convex.
+
+    Parameters
+    ----------
+    coordinates : (M+1, N+1, 2) array-like
+        The vertices. ``coordinates[m, n]`` specifies the (x, y) coordinates
+        of vertex (m, n).
+
+    Notes
+    -----
+    Unlike `.QuadMesh`, this class will draw each cell as an individual Polygon.
+    This is significantly slower, but allows for more flexibility when wanting
+    to add additional properties to the cells, such as hatching.
+
+    Another difference from `.QuadMesh` is that if any of the vertices or data
+    of a cell are masked, that Polygon will **not** be drawn and it won't be in
+    the list of paths returned.
+    """
+
+    def __init__(self, coordinates, **kwargs):
+        super().__init__(coordinates=coordinates)
+        PolyCollection.__init__(self, verts=[], **kwargs)
+        # Setting the verts updates the paths of the PolyCollection
+        # This is called after the initializers to make sure the kwargs
+        # have all been processed and available for the masking calculations
+        self._set_unmasked_verts()
+
+    def _get_unmasked_polys(self):
+        """Get the unmasked regions using the coordinates and array"""
+        # mask(X) | mask(Y)
+        mask = np.any(np.ma.getmaskarray(self._coordinates), axis=-1)
+
+        # We want the shape of the polygon, which is the corner of each X/Y array
+        mask = (mask[0:-1, 0:-1] | mask[1:, 1:] | mask[0:-1, 1:] | mask[1:, 0:-1])
+        arr = self.get_array()
+        if arr is not None:
+            arr = np.ma.getmaskarray(arr)
+            if arr.ndim == 3:
+                # RGB(A) case
+                mask |= np.any(arr, axis=-1)
+            elif arr.ndim == 2:
+                mask |= arr
+            else:
+                mask |= arr.reshape(self._coordinates[:-1, :-1, :].shape[:2])
+        return ~mask
+
+    def _set_unmasked_verts(self):
+        X = self._coordinates[..., 0]
+        Y = self._coordinates[..., 1]
+
+        unmask = self._get_unmasked_polys()
+        X1 = np.ma.filled(X[:-1, :-1])[unmask]
+        Y1 = np.ma.filled(Y[:-1, :-1])[unmask]
+        X2 = np.ma.filled(X[1:, :-1])[unmask]
+        Y2 = np.ma.filled(Y[1:, :-1])[unmask]
+        X3 = np.ma.filled(X[1:, 1:])[unmask]
+        Y3 = np.ma.filled(Y[1:, 1:])[unmask]
+        X4 = np.ma.filled(X[:-1, 1:])[unmask]
+        Y4 = np.ma.filled(Y[:-1, 1:])[unmask]
+        npoly = len(X1)
+
+        xy = np.ma.stack([X1, Y1, X2, Y2, X3, Y3, X4, Y4, X1, Y1], axis=-1)
+        verts = xy.reshape((npoly, 5, 2))
+        self.set_verts(verts)
+
+    def get_edgecolor(self):
+        # docstring inherited
+        # We only want to return the facecolors of the polygons
+        # that were drawn.
+        ec = super().get_edgecolor()
+        unmasked_polys = self._get_unmasked_polys().ravel()
+        if len(ec) != len(unmasked_polys):
+            # Mapping is off
+            return ec
+        return ec[unmasked_polys, :]
+
+    def get_facecolor(self):
+        # docstring inherited
+        # We only want to return the facecolors of the polygons
+        # that were drawn.
+        fc = super().get_facecolor()
+        unmasked_polys = self._get_unmasked_polys().ravel()
+        if len(fc) != len(unmasked_polys):
+            # Mapping is off
+            return fc
+        return fc[unmasked_polys, :]
+
+    def set_array(self, A):
+        # docstring inherited
+        prev_unmask = self._get_unmasked_polys()
+        super().set_array(A)
+        # If the mask has changed at all we need to update
+        # the set of Polys that we are drawing
+        if not np.array_equal(prev_unmask, self._get_unmasked_polys()):
+            self._set_unmasked_verts()

infer_4_37_2/lib/python3.10/site-packages/matplotlib/font_manager.py

@@ -0,0 +1,1645 @@
+"""
+A module for finding, managing, and using fonts across platforms.
+
+This module provides a single `FontManager` instance, ``fontManager``, that can
+be shared across backends and platforms.  The `findfont`
+function returns the best TrueType (TTF) font file in the local or
+system font path that matches the specified `FontProperties`
+instance.  The `FontManager` also handles Adobe Font Metrics
+(AFM) font files for use by the PostScript backend.
+The `FontManager.addfont` function adds a custom font from a file without
+installing it into your operating system.
+
+The design is based on the `W3C Cascading Style Sheet, Level 1 (CSS1)
+font specification <http://www.w3.org/TR/1998/REC-CSS2-19980512/>`_.
+Future versions may implement the Level 2 or 2.1 specifications.
+"""
+
+# KNOWN ISSUES
+#
+#   - documentation
+#   - font variant is untested
+#   - font stretch is incomplete
+#   - font size is incomplete
+#   - default font algorithm needs improvement and testing
+#   - setWeights function needs improvement
+#   - 'light' is an invalid weight value, remove it.
+
+from __future__ import annotations
+
+from base64 import b64encode
+import copy
+import dataclasses
+from functools import lru_cache
+import functools
+from io import BytesIO
+import json
+import logging
+from numbers import Number
+import os
+from pathlib import Path
+import plistlib
+import re
+import subprocess
+import sys
+import threading
+
+import matplotlib as mpl
+from matplotlib import _api, _afm, cbook, ft2font
+from matplotlib._fontconfig_pattern import (
+    parse_fontconfig_pattern, generate_fontconfig_pattern)
+from matplotlib.rcsetup import _validators
+
+_log = logging.getLogger(__name__)
+
+font_scalings = {
+    'xx-small': 0.579,
+    'x-small':  0.694,
+    'small':    0.833,
+    'medium':   1.0,
+    'large':    1.200,
+    'x-large':  1.440,
+    'xx-large': 1.728,
+    'larger':   1.2,
+    'smaller':  0.833,
+    None:       1.0,
+}
+stretch_dict = {
+    'ultra-condensed': 100,
+    'extra-condensed': 200,
+    'condensed':       300,
+    'semi-condensed':  400,
+    'normal':          500,
+    'semi-expanded':   600,
+    'semi-extended':   600,
+    'expanded':        700,
+    'extended':        700,
+    'extra-expanded':  800,
+    'extra-extended':  800,
+    'ultra-expanded':  900,
+    'ultra-extended':  900,
+}
+weight_dict = {
+    'ultralight': 100,
+    'light':      200,
+    'normal':     400,
+    'regular':    400,
+    'book':       400,
+    'medium':     500,
+    'roman':      500,
+    'semibold':   600,
+    'demibold':   600,
+    'demi':       600,
+    'bold':       700,
+    'heavy':      800,
+    'extra bold': 800,
+    'black':      900,
+}
+_weight_regexes = [
+    # From fontconfig's FcFreeTypeQueryFaceInternal; not the same as
+    # weight_dict!
+    ("thin", 100),
+    ("extralight", 200),
+    ("ultralight", 200),
+    ("demilight", 350),
+    ("semilight", 350),
+    ("light", 300),  # Needs to come *after* demi/semilight!
+    ("book", 380),
+    ("regular", 400),
+    ("normal", 400),
+    ("medium", 500),
+    ("demibold", 600),
+    ("demi", 600),
+    ("semibold", 600),
+    ("extrabold", 800),
+    ("superbold", 800),
+    ("ultrabold", 800),
+    ("bold", 700),  # Needs to come *after* extra/super/ultrabold!
+    ("ultrablack", 1000),
+    ("superblack", 1000),
+    ("extrablack", 1000),
+    (r"\bultra", 1000),
+    ("black", 900),  # Needs to come *after* ultra/super/extrablack!
+    ("heavy", 900),
+]
+font_family_aliases = {
+    'serif',
+    'sans-serif',
+    'sans serif',
+    'cursive',
+    'fantasy',
+    'monospace',
+    'sans',
+}
+
+# OS Font paths
+try:
+    _HOME = Path.home()
+except Exception:  # Exceptions thrown by home() are not specified...
+    _HOME = Path(os.devnull)  # Just an arbitrary path with no children.
+MSFolders = \
+    r'Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders'
+MSFontDirectories = [
+    r'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts',
+    r'SOFTWARE\Microsoft\Windows\CurrentVersion\Fonts']
+MSUserFontDirectories = [
+    str(_HOME / 'AppData/Local/Microsoft/Windows/Fonts'),
+    str(_HOME / 'AppData/Roaming/Microsoft/Windows/Fonts'),
+]
+X11FontDirectories = [
+    # an old standard installation point
+    "/usr/X11R6/lib/X11/fonts/TTF/",
+    "/usr/X11/lib/X11/fonts",
+    # here is the new standard location for fonts
+    "/usr/share/fonts/",
+    # documented as a good place to install new fonts
+    "/usr/local/share/fonts/",
+    # common application, not really useful
+    "/usr/lib/openoffice/share/fonts/truetype/",
+    # user fonts
+    str((Path(os.environ.get('XDG_DATA_HOME') or _HOME / ".local/share"))
+        / "fonts"),
+    str(_HOME / ".fonts"),
+]
+OSXFontDirectories = [
+    "/Library/Fonts/",
+    "/Network/Library/Fonts/",
+    "/System/Library/Fonts/",
+    # fonts installed via MacPorts
+    "/opt/local/share/fonts",
+    # user fonts
+    str(_HOME / "Library/Fonts"),
+]
+
+
+def get_fontext_synonyms(fontext):
+    """
+    Return a list of file extensions that are synonyms for
+    the given file extension *fileext*.
+    """
+    return {
+        'afm': ['afm'],
+        'otf': ['otf', 'ttc', 'ttf'],
+        'ttc': ['otf', 'ttc', 'ttf'],
+        'ttf': ['otf', 'ttc', 'ttf'],
+    }[fontext]
+
+
+def list_fonts(directory, extensions):
+    """
+    Return a list of all fonts matching any of the extensions, found
+    recursively under the directory.
+    """
+    extensions = ["." + ext for ext in extensions]
+    return [os.path.join(dirpath, filename)
+            # os.walk ignores access errors, unlike Path.glob.
+            for dirpath, _, filenames in os.walk(directory)
+            for filename in filenames
+            if Path(filename).suffix.lower() in extensions]
+
+
+def win32FontDirectory():
+    r"""
+    Return the user-specified font directory for Win32.  This is
+    looked up from the registry key ::
+
+      \\HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders\Fonts
+
+    If the key is not found, ``%WINDIR%\Fonts`` will be returned.
+    """  # noqa: E501
+    import winreg
+    try:
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, MSFolders) as user:
+            return winreg.QueryValueEx(user, 'Fonts')[0]
+    except OSError:
+        return os.path.join(os.environ['WINDIR'], 'Fonts')
+
+
+def _get_win32_installed_fonts():
+    """List the font paths known to the Windows registry."""
+    import winreg
+    items = set()
+    # Search and resolve fonts listed in the registry.
+    for domain, base_dirs in [
+            (winreg.HKEY_LOCAL_MACHINE, [win32FontDirectory()]),  # System.
+            (winreg.HKEY_CURRENT_USER, MSUserFontDirectories),  # User.
+    ]:
+        for base_dir in base_dirs:
+            for reg_path in MSFontDirectories:
+                try:
+                    with winreg.OpenKey(domain, reg_path) as local:
+                        for j in range(winreg.QueryInfoKey(local)[1]):
+                            # value may contain the filename of the font or its
+                            # absolute path.
+                            key, value, tp = winreg.EnumValue(local, j)
+                            if not isinstance(value, str):
+                                continue
+                            try:
+                                # If value contains already an absolute path,
+                                # then it is not changed further.
+                                path = Path(base_dir, value).resolve()
+                            except RuntimeError:
+                                # Don't fail with invalid entries.
+                                continue
+                            items.add(path)
+                except (OSError, MemoryError):
+                    continue
+    return items
+
+
+@lru_cache
+def _get_fontconfig_fonts():
+    """Cache and list the font paths known to ``fc-list``."""
+    try:
+        if b'--format' not in subprocess.check_output(['fc-list', '--help']):
+            _log.warning(  # fontconfig 2.7 implemented --format.
+                'Matplotlib needs fontconfig>=2.7 to query system fonts.')
+            return []
+        out = subprocess.check_output(['fc-list', '--format=%{file}\\n'])
+    except (OSError, subprocess.CalledProcessError):
+        return []
+    return [Path(os.fsdecode(fname)) for fname in out.split(b'\n')]
+
+
+@lru_cache
+def _get_macos_fonts():
+    """Cache and list the font paths known to ``system_profiler SPFontsDataType``."""
+    try:
+        d, = plistlib.loads(
+            subprocess.check_output(["system_profiler", "-xml", "SPFontsDataType"]))
+    except (OSError, subprocess.CalledProcessError, plistlib.InvalidFileException):
+        return []
+    return [Path(entry["path"]) for entry in d["_items"]]
+
+
+def findSystemFonts(fontpaths=None, fontext='ttf'):
+    """
+    Search for fonts in the specified font paths.  If no paths are
+    given, will use a standard set of system paths, as well as the
+    list of fonts tracked by fontconfig if fontconfig is installed and
+    available.  A list of TrueType fonts are returned by default with
+    AFM fonts as an option.
+    """
+    fontfiles = set()
+    fontexts = get_fontext_synonyms(fontext)
+
+    if fontpaths is None:
+        if sys.platform == 'win32':
+            installed_fonts = _get_win32_installed_fonts()
+            fontpaths = []
+        else:
+            installed_fonts = _get_fontconfig_fonts()
+            if sys.platform == 'darwin':
+                installed_fonts += _get_macos_fonts()
+                fontpaths = [*X11FontDirectories, *OSXFontDirectories]
+            else:
+                fontpaths = X11FontDirectories
+        fontfiles.update(str(path) for path in installed_fonts
+                         if path.suffix.lower()[1:] in fontexts)
+
+    elif isinstance(fontpaths, str):
+        fontpaths = [fontpaths]
+
+    for path in fontpaths:
+        fontfiles.update(map(os.path.abspath, list_fonts(path, fontexts)))
+
+    return [fname for fname in fontfiles if os.path.exists(fname)]
+
+
+@dataclasses.dataclass(frozen=True)
+class FontEntry:
+    """
+    A class for storing Font properties.
+
+    It is used when populating the font lookup dictionary.
+    """
+
+    fname: str = ''
+    name: str = ''
+    style: str = 'normal'
+    variant: str = 'normal'
+    weight: str | int = 'normal'
+    stretch: str = 'normal'
+    size: str = 'medium'
+
+    def _repr_html_(self) -> str:
+        png_stream = self._repr_png_()
+        png_b64 = b64encode(png_stream).decode()
+        return f"<img src=\"data:image/png;base64, {png_b64}\" />"
+
+    def _repr_png_(self) -> bytes:
+        from matplotlib.figure import Figure  # Circular import.
+        fig = Figure()
+        font_path = Path(self.fname) if self.fname != '' else None
+        fig.text(0, 0, self.name, font=font_path)
+        with BytesIO() as buf:
+            fig.savefig(buf, bbox_inches='tight', transparent=True)
+            return buf.getvalue()
+
+
+def ttfFontProperty(font):
+    """
+    Extract information from a TrueType font file.
+
+    Parameters
+    ----------
+    font : `.FT2Font`
+        The TrueType font file from which information will be extracted.
+
+    Returns
+    -------
+    `FontEntry`
+        The extracted font properties.
+
+    """
+    name = font.family_name
+
+    #  Styles are: italic, oblique, and normal (default)
+
+    sfnt = font.get_sfnt()
+    mac_key = (1,  # platform: macintosh
+               0,  # id: roman
+               0)  # langid: english
+    ms_key = (3,  # platform: microsoft
+              1,  # id: unicode_cs
+              0x0409)  # langid: english_united_states
+
+    # These tables are actually mac_roman-encoded, but mac_roman support may be
+    # missing in some alternative Python implementations and we are only going
+    # to look for ASCII substrings, where any ASCII-compatible encoding works
+    # - or big-endian UTF-16, since important Microsoft fonts use that.
+    sfnt2 = (sfnt.get((*mac_key, 2), b'').decode('latin-1').lower() or
+             sfnt.get((*ms_key, 2), b'').decode('utf_16_be').lower())
+    sfnt4 = (sfnt.get((*mac_key, 4), b'').decode('latin-1').lower() or
+             sfnt.get((*ms_key, 4), b'').decode('utf_16_be').lower())
+
+    if sfnt4.find('oblique') >= 0:
+        style = 'oblique'
+    elif sfnt4.find('italic') >= 0:
+        style = 'italic'
+    elif sfnt2.find('regular') >= 0:
+        style = 'normal'
+    elif ft2font.StyleFlags.ITALIC in font.style_flags:
+        style = 'italic'
+    else:
+        style = 'normal'
+
+    #  Variants are: small-caps and normal (default)
+
+    #  !!!!  Untested
+    if name.lower() in ['capitals', 'small-caps']:
+        variant = 'small-caps'
+    else:
+        variant = 'normal'
+
+    # The weight-guessing algorithm is directly translated from fontconfig
+    # 2.13.1's FcFreeTypeQueryFaceInternal (fcfreetype.c).
+    wws_subfamily = 22
+    typographic_subfamily = 16
+    font_subfamily = 2
+    styles = [
+        sfnt.get((*mac_key, wws_subfamily), b'').decode('latin-1'),
+        sfnt.get((*mac_key, typographic_subfamily), b'').decode('latin-1'),
+        sfnt.get((*mac_key, font_subfamily), b'').decode('latin-1'),
+        sfnt.get((*ms_key, wws_subfamily), b'').decode('utf-16-be'),
+        sfnt.get((*ms_key, typographic_subfamily), b'').decode('utf-16-be'),
+        sfnt.get((*ms_key, font_subfamily), b'').decode('utf-16-be'),
+    ]
+    styles = [*filter(None, styles)] or [font.style_name]
+
+    def get_weight():  # From fontconfig's FcFreeTypeQueryFaceInternal.
+        # OS/2 table weight.
+        os2 = font.get_sfnt_table("OS/2")
+        if os2 and os2["version"] != 0xffff:
+            return os2["usWeightClass"]
+        # PostScript font info weight.
+        try:
+            ps_font_info_weight = (
+                font.get_ps_font_info()["weight"].replace(" ", "") or "")
+        except ValueError:
+            pass
+        else:
+            for regex, weight in _weight_regexes:
+                if re.fullmatch(regex, ps_font_info_weight, re.I):
+                    return weight
+        # Style name weight.
+        for style in styles:
+            style = style.replace(" ", "")
+            for regex, weight in _weight_regexes:
+                if re.search(regex, style, re.I):
+                    return weight
+        if ft2font.StyleFlags.BOLD in font.style_flags:
+            return 700  # "bold"
+        return 500  # "medium", not "regular"!
+
+    weight = int(get_weight())
+
+    #  Stretch can be absolute and relative
+    #  Absolute stretches are: ultra-condensed, extra-condensed, condensed,
+    #    semi-condensed, normal, semi-expanded, expanded, extra-expanded,
+    #    and ultra-expanded.
+    #  Relative stretches are: wider, narrower
+    #  Child value is: inherit
+
+    if any(word in sfnt4 for word in ['narrow', 'condensed', 'cond']):
+        stretch = 'condensed'
+    elif 'demi cond' in sfnt4:
+        stretch = 'semi-condensed'
+    elif any(word in sfnt4 for word in ['wide', 'expanded', 'extended']):
+        stretch = 'expanded'
+    else:
+        stretch = 'normal'
+
+    #  Sizes can be absolute and relative.
+    #  Absolute sizes are: xx-small, x-small, small, medium, large, x-large,
+    #    and xx-large.
+    #  Relative sizes are: larger, smaller
+    #  Length value is an absolute font size, e.g., 12pt
+    #  Percentage values are in 'em's.  Most robust specification.
+
+    if not font.scalable:
+        raise NotImplementedError("Non-scalable fonts are not supported")
+    size = 'scalable'
+
+    return FontEntry(font.fname, name, style, variant, weight, stretch, size)
+
+
+def afmFontProperty(fontpath, font):
+    """
+    Extract information from an AFM font file.
+
+    Parameters
+    ----------
+    fontpath : str
+        The filename corresponding to *font*.
+    font : AFM
+        The AFM font file from which information will be extracted.
+
+    Returns
+    -------
+    `FontEntry`
+        The extracted font properties.
+    """
+
+    name = font.get_familyname()
+    fontname = font.get_fontname().lower()
+
+    #  Styles are: italic, oblique, and normal (default)
+
+    if font.get_angle() != 0 or 'italic' in name.lower():
+        style = 'italic'
+    elif 'oblique' in name.lower():
+        style = 'oblique'
+    else:
+        style = 'normal'
+
+    #  Variants are: small-caps and normal (default)
+
+    # !!!!  Untested
+    if name.lower() in ['capitals', 'small-caps']:
+        variant = 'small-caps'
+    else:
+        variant = 'normal'
+
+    weight = font.get_weight().lower()
+    if weight not in weight_dict:
+        weight = 'normal'
+
+    #  Stretch can be absolute and relative
+    #  Absolute stretches are: ultra-condensed, extra-condensed, condensed,
+    #    semi-condensed, normal, semi-expanded, expanded, extra-expanded,
+    #    and ultra-expanded.
+    #  Relative stretches are: wider, narrower
+    #  Child value is: inherit
+    if 'demi cond' in fontname:
+        stretch = 'semi-condensed'
+    elif any(word in fontname for word in ['narrow', 'cond']):
+        stretch = 'condensed'
+    elif any(word in fontname for word in ['wide', 'expanded', 'extended']):
+        stretch = 'expanded'
+    else:
+        stretch = 'normal'
+
+    #  Sizes can be absolute and relative.
+    #  Absolute sizes are: xx-small, x-small, small, medium, large, x-large,
+    #    and xx-large.
+    #  Relative sizes are: larger, smaller
+    #  Length value is an absolute font size, e.g., 12pt
+    #  Percentage values are in 'em's.  Most robust specification.
+
+    #  All AFM fonts are apparently scalable.
+
+    size = 'scalable'
+
+    return FontEntry(fontpath, name, style, variant, weight, stretch, size)
+
+
+def _cleanup_fontproperties_init(init_method):
+    """
+    A decorator to limit the call signature to single a positional argument
+    or alternatively only keyword arguments.
+
+    We still accept but deprecate all other call signatures.
+
+    When the deprecation expires we can switch the signature to::
+
+        __init__(self, pattern=None, /, *, family=None, style=None, ...)
+
+    plus a runtime check that pattern is not used alongside with the
+    keyword arguments. This results eventually in the two possible
+    call signatures::
+
+        FontProperties(pattern)
+        FontProperties(family=..., size=..., ...)
+
+    """
+    @functools.wraps(init_method)
+    def wrapper(self, *args, **kwargs):
+        # multiple args with at least some positional ones
+        if len(args) > 1 or len(args) == 1 and kwargs:
+            # Note: Both cases were previously handled as individual properties.
+            # Therefore, we do not mention the case of font properties here.
+            _api.warn_deprecated(
+                "3.10",
+                message="Passing individual properties to FontProperties() "
+                        "positionally was deprecated in Matplotlib %(since)s and "
+                        "will be removed in %(removal)s. Please pass all properties "
+                        "via keyword arguments."
+            )
+        # single non-string arg -> clearly a family not a pattern
+        if len(args) == 1 and not kwargs and not cbook.is_scalar_or_string(args[0]):
+            # Case font-family list passed as single argument
+            _api.warn_deprecated(
+                "3.10",
+                message="Passing family as positional argument to FontProperties() "
+                        "was deprecated in Matplotlib %(since)s and will be removed "
+                        "in %(removal)s. Please pass family names as keyword"
+                        "argument."
+            )
+        # Note on single string arg:
+        # This has been interpreted as pattern so far. We are already raising if a
+        # non-pattern compatible family string was given. Therefore, we do not need
+        # to warn for this case.
+        return init_method(self, *args, **kwargs)
+
+    return wrapper
+
+
+class FontProperties:
+    """
+    A class for storing and manipulating font properties.
+
+    The font properties are the six properties described in the
+    `W3C Cascading Style Sheet, Level 1
+    <http://www.w3.org/TR/1998/REC-CSS2-19980512/>`_ font
+    specification and *math_fontfamily* for math fonts:
+
+    - family: A list of font names in decreasing order of priority.
+      The items may include a generic font family name, either 'sans-serif',
+      'serif', 'cursive', 'fantasy', or 'monospace'.  In that case, the actual
+      font to be used will be looked up from the associated rcParam during the
+      search process in `.findfont`. Default: :rc:`font.family`
+
+    - style: Either 'normal', 'italic' or 'oblique'.
+      Default: :rc:`font.style`
+
+    - variant: Either 'normal' or 'small-caps'.
+      Default: :rc:`font.variant`
+
+    - stretch: A numeric value in the range 0-1000 or one of
+      'ultra-condensed', 'extra-condensed', 'condensed',
+      'semi-condensed', 'normal', 'semi-expanded', 'expanded',
+      'extra-expanded' or 'ultra-expanded'. Default: :rc:`font.stretch`
+
+    - weight: A numeric value in the range 0-1000 or one of
+      'ultralight', 'light', 'normal', 'regular', 'book', 'medium',
+      'roman', 'semibold', 'demibold', 'demi', 'bold', 'heavy',
+      'extra bold', 'black'. Default: :rc:`font.weight`
+
+    - size: Either a relative value of 'xx-small', 'x-small',
+      'small', 'medium', 'large', 'x-large', 'xx-large' or an
+      absolute font size, e.g., 10. Default: :rc:`font.size`
+
+    - math_fontfamily: The family of fonts used to render math text.
+      Supported values are: 'dejavusans', 'dejavuserif', 'cm',
+      'stix', 'stixsans' and 'custom'. Default: :rc:`mathtext.fontset`
+
+    Alternatively, a font may be specified using the absolute path to a font
+    file, by using the *fname* kwarg.  However, in this case, it is typically
+    simpler to just pass the path (as a `pathlib.Path`, not a `str`) to the
+    *font* kwarg of the `.Text` object.
+
+    The preferred usage of font sizes is to use the relative values,
+    e.g.,  'large', instead of absolute font sizes, e.g., 12.  This
+    approach allows all text sizes to be made larger or smaller based
+    on the font manager's default font size.
+
+    This class accepts a single positional string as fontconfig_ pattern_,
+    or alternatively individual properties as keyword arguments::
+
+        FontProperties(pattern)
+        FontProperties(*, family=None, style=None, variant=None, ...)
+
+    This support does not depend on fontconfig; we are merely borrowing its
+    pattern syntax for use here.
+
+    .. _fontconfig: https://www.freedesktop.org/wiki/Software/fontconfig/
+    .. _pattern:
+       https://www.freedesktop.org/software/fontconfig/fontconfig-user.html
+
+    Note that Matplotlib's internal font manager and fontconfig use a
+    different algorithm to lookup fonts, so the results of the same pattern
+    may be different in Matplotlib than in other applications that use
+    fontconfig.
+    """
+
+    @_cleanup_fontproperties_init
+    def __init__(self, family=None, style=None, variant=None, weight=None,
+                 stretch=None, size=None,
+                 fname=None,  # if set, it's a hardcoded filename to use
+                 math_fontfamily=None):
+        self.set_family(family)
+        self.set_style(style)
+        self.set_variant(variant)
+        self.set_weight(weight)
+        self.set_stretch(stretch)
+        self.set_file(fname)
+        self.set_size(size)
+        self.set_math_fontfamily(math_fontfamily)
+        # Treat family as a fontconfig pattern if it is the only parameter
+        # provided.  Even in that case, call the other setters first to set
+        # attributes not specified by the pattern to the rcParams defaults.
+        if (isinstance(family, str)
+                and style is None and variant is None and weight is None
+                and stretch is None and size is None and fname is None):
+            self.set_fontconfig_pattern(family)
+
+    @classmethod
+    def _from_any(cls, arg):
+        """
+        Generic constructor which can build a `.FontProperties` from any of the
+        following:
+
+        - a `.FontProperties`: it is passed through as is;
+        - `None`: a `.FontProperties` using rc values is used;
+        - an `os.PathLike`: it is used as path to the font file;
+        - a `str`: it is parsed as a fontconfig pattern;
+        - a `dict`: it is passed as ``**kwargs`` to `.FontProperties`.
+        """
+        if arg is None:
+            return cls()
+        elif isinstance(arg, cls):
+            return arg
+        elif isinstance(arg, os.PathLike):
+            return cls(fname=arg)
+        elif isinstance(arg, str):
+            return cls(arg)
+        else:
+            return cls(**arg)
+
+    def __hash__(self):
+        l = (tuple(self.get_family()),
+             self.get_slant(),
+             self.get_variant(),
+             self.get_weight(),
+             self.get_stretch(),
+             self.get_size(),
+             self.get_file(),
+             self.get_math_fontfamily())
+        return hash(l)
+
+    def __eq__(self, other):
+        return hash(self) == hash(other)
+
+    def __str__(self):
+        return self.get_fontconfig_pattern()
+
+    def get_family(self):
+        """
+        Return a list of individual font family names or generic family names.
+
+        The font families or generic font families (which will be resolved
+        from their respective rcParams when searching for a matching font) in
+        the order of preference.
+        """
+        return self._family
+
+    def get_name(self):
+        """
+        Return the name of the font that best matches the font properties.
+        """
+        return get_font(findfont(self)).family_name
+
+    def get_style(self):
+        """
+        Return the font style.  Values are: 'normal', 'italic' or 'oblique'.
+        """
+        return self._slant
+
+    def get_variant(self):
+        """
+        Return the font variant.  Values are: 'normal' or 'small-caps'.
+        """
+        return self._variant
+
+    def get_weight(self):
+        """
+        Set the font weight.  Options are: A numeric value in the
+        range 0-1000 or one of 'light', 'normal', 'regular', 'book',
+        'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold',
+        'heavy', 'extra bold', 'black'
+        """
+        return self._weight
+
+    def get_stretch(self):
+        """
+        Return the font stretch or width.  Options are: 'ultra-condensed',
+        'extra-condensed', 'condensed', 'semi-condensed', 'normal',
+        'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded'.
+        """
+        return self._stretch
+
+    def get_size(self):
+        """
+        Return the font size.
+        """
+        return self._size
+
+    def get_file(self):
+        """
+        Return the filename of the associated font.
+        """
+        return self._file
+
+    def get_fontconfig_pattern(self):
+        """
+        Get a fontconfig_ pattern_ suitable for looking up the font as
+        specified with fontconfig's ``fc-match`` utility.
+
+        This support does not depend on fontconfig; we are merely borrowing its
+        pattern syntax for use here.
+        """
+        return generate_fontconfig_pattern(self)
+
+    def set_family(self, family):
+        """
+        Change the font family.  Can be either an alias (generic name
+        is CSS parlance), such as: 'serif', 'sans-serif', 'cursive',
+        'fantasy', or 'monospace', a real font name or a list of real
+        font names.  Real font names are not supported when
+        :rc:`text.usetex` is `True`. Default: :rc:`font.family`
+        """
+        if family is None:
+            family = mpl.rcParams['font.family']
+        if isinstance(family, str):
+            family = [family]
+        self._family = family
+
+    def set_style(self, style):
+        """
+        Set the font style.
+
+        Parameters
+        ----------
+        style : {'normal', 'italic', 'oblique'}, default: :rc:`font.style`
+        """
+        if style is None:
+            style = mpl.rcParams['font.style']
+        _api.check_in_list(['normal', 'italic', 'oblique'], style=style)
+        self._slant = style
+
+    def set_variant(self, variant):
+        """
+        Set the font variant.
+
+        Parameters
+        ----------
+        variant : {'normal', 'small-caps'}, default: :rc:`font.variant`
+        """
+        if variant is None:
+            variant = mpl.rcParams['font.variant']
+        _api.check_in_list(['normal', 'small-caps'], variant=variant)
+        self._variant = variant
+
+    def set_weight(self, weight):
+        """
+        Set the font weight.
+
+        Parameters
+        ----------
+        weight : int or {'ultralight', 'light', 'normal', 'regular', 'book', \
+'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold', 'heavy', \
+'extra bold', 'black'}, default: :rc:`font.weight`
+            If int, must be in the range  0-1000.
+        """
+        if weight is None:
+            weight = mpl.rcParams['font.weight']
+        if weight in weight_dict:
+            self._weight = weight
+            return
+        try:
+            weight = int(weight)
+        except ValueError:
+            pass
+        else:
+            if 0 <= weight <= 1000:
+                self._weight = weight
+                return
+        raise ValueError(f"{weight=} is invalid")
+
+    def set_stretch(self, stretch):
+        """
+        Set the font stretch or width.
+
+        Parameters
+        ----------
+        stretch : int or {'ultra-condensed', 'extra-condensed', 'condensed', \
+'semi-condensed', 'normal', 'semi-expanded', 'expanded', 'extra-expanded', \
+'ultra-expanded'}, default: :rc:`font.stretch`
+            If int, must be in the range  0-1000.
+        """
+        if stretch is None:
+            stretch = mpl.rcParams['font.stretch']
+        if stretch in stretch_dict:
+            self._stretch = stretch
+            return
+        try:
+            stretch = int(stretch)
+        except ValueError:
+            pass
+        else:
+            if 0 <= stretch <= 1000:
+                self._stretch = stretch
+                return
+        raise ValueError(f"{stretch=} is invalid")
+
+    def set_size(self, size):
+        """
+        Set the font size.
+
+        Parameters
+        ----------
+        size : float or {'xx-small', 'x-small', 'small', 'medium', \
+'large', 'x-large', 'xx-large'}, default: :rc:`font.size`
+            If a float, the font size in points. The string values denote
+            sizes relative to the default font size.
+        """
+        if size is None:
+            size = mpl.rcParams['font.size']
+        try:
+            size = float(size)
+        except ValueError:
+            try:
+                scale = font_scalings[size]
+            except KeyError as err:
+                raise ValueError(
+                    "Size is invalid. Valid font size are "
+                    + ", ".join(map(str, font_scalings))) from err
+            else:
+                size = scale * FontManager.get_default_size()
+        if size < 1.0:
+            _log.info('Fontsize %1.2f < 1.0 pt not allowed by FreeType. '
+                      'Setting fontsize = 1 pt', size)
+            size = 1.0
+        self._size = size
+
+    def set_file(self, file):
+        """
+        Set the filename of the fontfile to use.  In this case, all
+        other properties will be ignored.
+        """
+        self._file = os.fspath(file) if file is not None else None
+
+    def set_fontconfig_pattern(self, pattern):
+        """
+        Set the properties by parsing a fontconfig_ *pattern*.
+
+        This support does not depend on fontconfig; we are merely borrowing its
+        pattern syntax for use here.
+        """
+        for key, val in parse_fontconfig_pattern(pattern).items():
+            if type(val) is list:
+                getattr(self, "set_" + key)(val[0])
+            else:
+                getattr(self, "set_" + key)(val)
+
+    def get_math_fontfamily(self):
+        """
+        Return the name of the font family used for math text.
+
+        The default font is :rc:`mathtext.fontset`.
+        """
+        return self._math_fontfamily
+
+    def set_math_fontfamily(self, fontfamily):
+        """
+        Set the font family for text in math mode.
+
+        If not set explicitly, :rc:`mathtext.fontset` will be used.
+
+        Parameters
+        ----------
+        fontfamily : str
+            The name of the font family.
+
+            Available font families are defined in the
+            :ref:`default matplotlibrc file <customizing-with-matplotlibrc-files>`.
+
+        See Also
+        --------
+        .text.Text.get_math_fontfamily
+        """
+        if fontfamily is None:
+            fontfamily = mpl.rcParams['mathtext.fontset']
+        else:
+            valid_fonts = _validators['mathtext.fontset'].valid.values()
+            # _check_in_list() Validates the parameter math_fontfamily as
+            # if it were passed to rcParams['mathtext.fontset']
+            _api.check_in_list(valid_fonts, math_fontfamily=fontfamily)
+        self._math_fontfamily = fontfamily
+
+    def copy(self):
+        """Return a copy of self."""
+        return copy.copy(self)
+
+    # Aliases
+    set_name = set_family
+    get_slant = get_style
+    set_slant = set_style
+    get_size_in_points = get_size
+
+
+class _JSONEncoder(json.JSONEncoder):
+    def default(self, o):
+        if isinstance(o, FontManager):
+            return dict(o.__dict__, __class__='FontManager')
+        elif isinstance(o, FontEntry):
+            d = dict(o.__dict__, __class__='FontEntry')
+            try:
+                # Cache paths of fonts shipped with Matplotlib relative to the
+                # Matplotlib data path, which helps in the presence of venvs.
+                d["fname"] = str(Path(d["fname"]).relative_to(mpl.get_data_path()))
+            except ValueError:
+                pass
+            return d
+        else:
+            return super().default(o)
+
+
+def _json_decode(o):
+    cls = o.pop('__class__', None)
+    if cls is None:
+        return o
+    elif cls == 'FontManager':
+        r = FontManager.__new__(FontManager)
+        r.__dict__.update(o)
+        return r
+    elif cls == 'FontEntry':
+        if not os.path.isabs(o['fname']):
+            o['fname'] = os.path.join(mpl.get_data_path(), o['fname'])
+        r = FontEntry(**o)
+        return r
+    else:
+        raise ValueError("Don't know how to deserialize __class__=%s" % cls)
+
+
+def json_dump(data, filename):
+    """
+    Dump `FontManager` *data* as JSON to the file named *filename*.
+
+    See Also
+    --------
+    json_load
+
+    Notes
+    -----
+    File paths that are children of the Matplotlib data path (typically, fonts
+    shipped with Matplotlib) are stored relative to that data path (to remain
+    valid across virtualenvs).
+
+    This function temporarily locks the output file to prevent multiple
+    processes from overwriting one another's output.
+    """
+    try:
+        with cbook._lock_path(filename), open(filename, 'w') as fh:
+            json.dump(data, fh, cls=_JSONEncoder, indent=2)
+    except OSError as e:
+        _log.warning('Could not save font_manager cache %s', e)
+
+
+def json_load(filename):
+    """
+    Load a `FontManager` from the JSON file named *filename*.
+
+    See Also
+    --------
+    json_dump
+    """
+    with open(filename) as fh:
+        return json.load(fh, object_hook=_json_decode)
+
+
+class FontManager:
+    """
+    On import, the `FontManager` singleton instance creates a list of ttf and
+    afm fonts and caches their `FontProperties`.  The `FontManager.findfont`
+    method does a nearest neighbor search to find the font that most closely
+    matches the specification.  If no good enough match is found, the default
+    font is returned.
+
+    Fonts added with the `FontManager.addfont` method will not persist in the
+    cache; therefore, `addfont` will need to be called every time Matplotlib is
+    imported. This method should only be used if and when a font cannot be
+    installed on your operating system by other means.
+
+    Notes
+    -----
+    The `FontManager.addfont` method must be called on the global `FontManager`
+    instance.
+
+    Example usage::
+
+        import matplotlib.pyplot as plt
+        from matplotlib import font_manager
+
+        font_dirs = ["/resources/fonts"]  # The path to the custom font file.
+        font_files = font_manager.findSystemFonts(fontpaths=font_dirs)
+
+        for font_file in font_files:
+            font_manager.fontManager.addfont(font_file)
+    """
+    # Increment this version number whenever the font cache data
+    # format or behavior has changed and requires an existing font
+    # cache files to be rebuilt.
+    __version__ = 390
+
+    def __init__(self, size=None, weight='normal'):
+        self._version = self.__version__
+
+        self.__default_weight = weight
+        self.default_size = size
+
+        # Create list of font paths.
+        paths = [cbook._get_data_path('fonts', subdir)
+                 for subdir in ['ttf', 'afm', 'pdfcorefonts']]
+        _log.debug('font search path %s', paths)
+
+        self.defaultFamily = {
+            'ttf': 'DejaVu Sans',
+            'afm': 'Helvetica'}
+
+        self.afmlist = []
+        self.ttflist = []
+
+        # Delay the warning by 5s.
+        timer = threading.Timer(5, lambda: _log.warning(
+            'Matplotlib is building the font cache; this may take a moment.'))
+        timer.start()
+        try:
+            for fontext in ["afm", "ttf"]:
+                for path in [*findSystemFonts(paths, fontext=fontext),
+                             *findSystemFonts(fontext=fontext)]:
+                    try:
+                        self.addfont(path)
+                    except OSError as exc:
+                        _log.info("Failed to open font file %s: %s", path, exc)
+                    except Exception as exc:
+                        _log.info("Failed to extract font properties from %s: "
+                                  "%s", path, exc)
+        finally:
+            timer.cancel()
+
+    def addfont(self, path):
+        """
+        Cache the properties of the font at *path* to make it available to the
+        `FontManager`.  The type of font is inferred from the path suffix.
+
+        Parameters
+        ----------
+        path : str or path-like
+
+        Notes
+        -----
+        This method is useful for adding a custom font without installing it in
+        your operating system. See the `FontManager` singleton instance for
+        usage and caveats about this function.
+        """
+        # Convert to string in case of a path as
+        # afmFontProperty and FT2Font expect this
+        path = os.fsdecode(path)
+        if Path(path).suffix.lower() == ".afm":
+            with open(path, "rb") as fh:
+                font = _afm.AFM(fh)
+            prop = afmFontProperty(path, font)
+            self.afmlist.append(prop)
+        else:
+            font = ft2font.FT2Font(path)
+            prop = ttfFontProperty(font)
+            self.ttflist.append(prop)
+        self._findfont_cached.cache_clear()
+
+    @property
+    def defaultFont(self):
+        # Lazily evaluated (findfont then caches the result) to avoid including
+        # the venv path in the json serialization.
+        return {ext: self.findfont(family, fontext=ext)
+                for ext, family in self.defaultFamily.items()}
+
+    def get_default_weight(self):
+        """
+        Return the default font weight.
+        """
+        return self.__default_weight
+
+    @staticmethod
+    def get_default_size():
+        """
+        Return the default font size.
+        """
+        return mpl.rcParams['font.size']
+
+    def set_default_weight(self, weight):
+        """
+        Set the default font weight.  The initial value is 'normal'.
+        """
+        self.__default_weight = weight
+
+    @staticmethod
+    def _expand_aliases(family):
+        if family in ('sans', 'sans serif'):
+            family = 'sans-serif'
+        return mpl.rcParams['font.' + family]
+
+    # Each of the scoring functions below should return a value between
+    # 0.0 (perfect match) and 1.0 (terrible match)
+    def score_family(self, families, family2):
+        """
+        Return a match score between the list of font families in
+        *families* and the font family name *family2*.
+
+        An exact match at the head of the list returns 0.0.
+
+        A match further down the list will return between 0 and 1.
+
+        No match will return 1.0.
+        """
+        if not isinstance(families, (list, tuple)):
+            families = [families]
+        elif len(families) == 0:
+            return 1.0
+        family2 = family2.lower()
+        step = 1 / len(families)
+        for i, family1 in enumerate(families):
+            family1 = family1.lower()
+            if family1 in font_family_aliases:
+                options = [*map(str.lower, self._expand_aliases(family1))]
+                if family2 in options:
+                    idx = options.index(family2)
+                    return (i + (idx / len(options))) * step
+            elif family1 == family2:
+                # The score should be weighted by where in the
+                # list the font was found.
+                return i * step
+        return 1.0
+
+    def score_style(self, style1, style2):
+        """
+        Return a match score between *style1* and *style2*.
+
+        An exact match returns 0.0.
+
+        A match between 'italic' and 'oblique' returns 0.1.
+
+        No match returns 1.0.
+        """
+        if style1 == style2:
+            return 0.0
+        elif (style1 in ('italic', 'oblique')
+              and style2 in ('italic', 'oblique')):
+            return 0.1
+        return 1.0
+
+    def score_variant(self, variant1, variant2):
+        """
+        Return a match score between *variant1* and *variant2*.
+
+        An exact match returns 0.0, otherwise 1.0.
+        """
+        if variant1 == variant2:
+            return 0.0
+        else:
+            return 1.0
+
+    def score_stretch(self, stretch1, stretch2):
+        """
+        Return a match score between *stretch1* and *stretch2*.
+
+        The result is the absolute value of the difference between the
+        CSS numeric values of *stretch1* and *stretch2*, normalized
+        between 0.0 and 1.0.
+        """
+        try:
+            stretchval1 = int(stretch1)
+        except ValueError:
+            stretchval1 = stretch_dict.get(stretch1, 500)
+        try:
+            stretchval2 = int(stretch2)
+        except ValueError:
+            stretchval2 = stretch_dict.get(stretch2, 500)
+        return abs(stretchval1 - stretchval2) / 1000.0
+
+    def score_weight(self, weight1, weight2):
+        """
+        Return a match score between *weight1* and *weight2*.
+
+        The result is 0.0 if both weight1 and weight 2 are given as strings
+        and have the same value.
+
+        Otherwise, the result is the absolute value of the difference between
+        the CSS numeric values of *weight1* and *weight2*, normalized between
+        0.05 and 1.0.
+        """
+        # exact match of the weight names, e.g. weight1 == weight2 == "regular"
+        if cbook._str_equal(weight1, weight2):
+            return 0.0
+        w1 = weight1 if isinstance(weight1, Number) else weight_dict[weight1]
+        w2 = weight2 if isinstance(weight2, Number) else weight_dict[weight2]
+        return 0.95 * (abs(w1 - w2) / 1000) + 0.05
+
+    def score_size(self, size1, size2):
+        """
+        Return a match score between *size1* and *size2*.
+
+        If *size2* (the size specified in the font file) is 'scalable', this
+        function always returns 0.0, since any font size can be generated.
+
+        Otherwise, the result is the absolute distance between *size1* and
+        *size2*, normalized so that the usual range of font sizes (6pt -
+        72pt) will lie between 0.0 and 1.0.
+        """
+        if size2 == 'scalable':
+            return 0.0
+        # Size value should have already been
+        try:
+            sizeval1 = float(size1)
+        except ValueError:
+            sizeval1 = self.default_size * font_scalings[size1]
+        try:
+            sizeval2 = float(size2)
+        except ValueError:
+            return 1.0
+        return abs(sizeval1 - sizeval2) / 72
+
+    def findfont(self, prop, fontext='ttf', directory=None,
+                 fallback_to_default=True, rebuild_if_missing=True):
+        """
+        Find the path to the font file most closely matching the given font properties.
+
+        Parameters
+        ----------
+        prop : str or `~matplotlib.font_manager.FontProperties`
+            The font properties to search for. This can be either a
+            `.FontProperties` object or a string defining a
+            `fontconfig patterns`_.
+
+        fontext : {'ttf', 'afm'}, default: 'ttf'
+            The extension of the font file:
+
+            - 'ttf': TrueType and OpenType fonts (.ttf, .ttc, .otf)
+            - 'afm': Adobe Font Metrics (.afm)
+
+        directory : str, optional
+            If given, only search this directory and its subdirectories.
+
+        fallback_to_default : bool
+            If True, will fall back to the default font family (usually
+            "DejaVu Sans" or "Helvetica") if the first lookup hard-fails.
+
+        rebuild_if_missing : bool
+            Whether to rebuild the font cache and search again if the first
+            match appears to point to a nonexisting font (i.e., the font cache
+            contains outdated entries).
+
+        Returns
+        -------
+        str
+            The filename of the best matching font.
+
+        Notes
+        -----
+        This performs a nearest neighbor search.  Each font is given a
+        similarity score to the target font properties.  The first font with
+        the highest score is returned.  If no matches below a certain
+        threshold are found, the default font (usually DejaVu Sans) is
+        returned.
+
+        The result is cached, so subsequent lookups don't have to
+        perform the O(n) nearest neighbor search.
+
+        See the `W3C Cascading Style Sheet, Level 1
+        <http://www.w3.org/TR/1998/REC-CSS2-19980512/>`_ documentation
+        for a description of the font finding algorithm.
+
+        .. _fontconfig patterns:
+           https://www.freedesktop.org/software/fontconfig/fontconfig-user.html
+        """
+        # Pass the relevant rcParams (and the font manager, as `self`) to
+        # _findfont_cached so to prevent using a stale cache entry after an
+        # rcParam was changed.
+        rc_params = tuple(tuple(mpl.rcParams[key]) for key in [
+            "font.serif", "font.sans-serif", "font.cursive", "font.fantasy",
+            "font.monospace"])
+        ret = self._findfont_cached(
+            prop, fontext, directory, fallback_to_default, rebuild_if_missing,
+            rc_params)
+        if isinstance(ret, cbook._ExceptionInfo):
+            raise ret.to_exception()
+        return ret
+
+    def get_font_names(self):
+        """Return the list of available fonts."""
+        return list({font.name for font in self.ttflist})
+
+    def _find_fonts_by_props(self, prop, fontext='ttf', directory=None,
+                             fallback_to_default=True, rebuild_if_missing=True):
+        """
+        Find the paths to the font files most closely matching the given properties.
+
+        Parameters
+        ----------
+        prop : str or `~matplotlib.font_manager.FontProperties`
+            The font properties to search for. This can be either a
+            `.FontProperties` object or a string defining a
+            `fontconfig patterns`_.
+
+        fontext : {'ttf', 'afm'}, default: 'ttf'
+            The extension of the font file:
+
+            - 'ttf': TrueType and OpenType fonts (.ttf, .ttc, .otf)
+            - 'afm': Adobe Font Metrics (.afm)
+
+        directory : str, optional
+            If given, only search this directory and its subdirectories.
+
+        fallback_to_default : bool
+            If True, will fall back to the default font family (usually
+            "DejaVu Sans" or "Helvetica") if none of the families were found.
+
+        rebuild_if_missing : bool
+            Whether to rebuild the font cache and search again if the first
+            match appears to point to a nonexisting font (i.e., the font cache
+            contains outdated entries).
+
+        Returns
+        -------
+        list[str]
+            The paths of the fonts found.
+
+        Notes
+        -----
+        This is an extension/wrapper of the original findfont API, which only
+        returns a single font for given font properties. Instead, this API
+        returns a list of filepaths of multiple fonts which closely match the
+        given font properties.  Since this internally uses the original API,
+        there's no change to the logic of performing the nearest neighbor
+        search.  See `findfont` for more details.
+        """
+
+        prop = FontProperties._from_any(prop)
+
+        fpaths = []
+        for family in prop.get_family():
+            cprop = prop.copy()
+            cprop.set_family(family)  # set current prop's family
+
+            try:
+                fpaths.append(
+                    self.findfont(
+                        cprop, fontext, directory,
+                        fallback_to_default=False,  # don't fallback to default
+                        rebuild_if_missing=rebuild_if_missing,
+                    )
+                )
+            except ValueError:
+                if family in font_family_aliases:
+                    _log.warning(
+                        "findfont: Generic family %r not found because "
+                        "none of the following families were found: %s",
+                        family, ", ".join(self._expand_aliases(family))
+                    )
+                else:
+                    _log.warning("findfont: Font family %r not found.", family)
+
+        # only add default family if no other font was found and
+        # fallback_to_default is enabled
+        if not fpaths:
+            if fallback_to_default:
+                dfamily = self.defaultFamily[fontext]
+                cprop = prop.copy()
+                cprop.set_family(dfamily)
+                fpaths.append(
+                    self.findfont(
+                        cprop, fontext, directory,
+                        fallback_to_default=True,
+                        rebuild_if_missing=rebuild_if_missing,
+                    )
+                )
+            else:
+                raise ValueError("Failed to find any font, and fallback "
+                                 "to the default font was disabled")
+
+        return fpaths
+
+    @lru_cache(1024)
+    def _findfont_cached(self, prop, fontext, directory, fallback_to_default,
+                         rebuild_if_missing, rc_params):
+
+        prop = FontProperties._from_any(prop)
+
+        fname = prop.get_file()
+        if fname is not None:
+            return fname
+
+        if fontext == 'afm':
+            fontlist = self.afmlist
+        else:
+            fontlist = self.ttflist
+
+        best_score = 1e64
+        best_font = None
+
+        _log.debug('findfont: Matching %s.', prop)
+        for font in fontlist:
+            if (directory is not None and
+                    Path(directory) not in Path(font.fname).parents):
+                continue
+            # Matching family should have top priority, so multiply it by 10.
+            score = (self.score_family(prop.get_family(), font.name) * 10
+                     + self.score_style(prop.get_style(), font.style)
+                     + self.score_variant(prop.get_variant(), font.variant)
+                     + self.score_weight(prop.get_weight(), font.weight)
+                     + self.score_stretch(prop.get_stretch(), font.stretch)
+                     + self.score_size(prop.get_size(), font.size))
+            _log.debug('findfont: score(%s) = %s', font, score)
+            if score < best_score:
+                best_score = score
+                best_font = font
+            if score == 0:
+                break
+
+        if best_font is None or best_score >= 10.0:
+            if fallback_to_default:
+                _log.warning(
+                    'findfont: Font family %s not found. Falling back to %s.',
+                    prop.get_family(), self.defaultFamily[fontext])
+                for family in map(str.lower, prop.get_family()):
+                    if family in font_family_aliases:
+                        _log.warning(
+                            "findfont: Generic family %r not found because "
+                            "none of the following families were found: %s",
+                            family, ", ".join(self._expand_aliases(family)))
+                default_prop = prop.copy()
+                default_prop.set_family(self.defaultFamily[fontext])
+                return self.findfont(default_prop, fontext, directory,
+                                     fallback_to_default=False)
+            else:
+                # This return instead of raise is intentional, as we wish to
+                # cache that it was not found, which will not occur if it was
+                # actually raised.
+                return cbook._ExceptionInfo(
+                    ValueError,
+                    f"Failed to find font {prop}, and fallback to the default font was "
+                    f"disabled"
+                )
+        else:
+            _log.debug('findfont: Matching %s to %s (%r) with score of %f.',
+                       prop, best_font.name, best_font.fname, best_score)
+            result = best_font.fname
+
+        if not os.path.isfile(result):
+            if rebuild_if_missing:
+                _log.info(
+                    'findfont: Found a missing font file.  Rebuilding cache.')
+                new_fm = _load_fontmanager(try_read_cache=False)
+                # Replace self by the new fontmanager, because users may have
+                # a reference to this specific instance.
+                # TODO: _load_fontmanager should really be (used by) a method
+                # modifying the instance in place.
+                vars(self).update(vars(new_fm))
+                return self.findfont(
+                    prop, fontext, directory, rebuild_if_missing=False)
+            else:
+                # This return instead of raise is intentional, as we wish to
+                # cache that it was not found, which will not occur if it was
+                # actually raised.
+                return cbook._ExceptionInfo(ValueError, "No valid font could be found")
+
+        return _cached_realpath(result)
+
+
+@lru_cache
+def is_opentype_cff_font(filename):
+    """
+    Return whether the given font is a Postscript Compact Font Format Font
+    embedded in an OpenType wrapper.  Used by the PostScript and PDF backends
+    that cannot subset these fonts.
+    """
+    if os.path.splitext(filename)[1].lower() == '.otf':
+        with open(filename, 'rb') as fd:
+            return fd.read(4) == b"OTTO"
+    else:
+        return False
+
+
+@lru_cache(64)
+def _get_font(font_filepaths, hinting_factor, *, _kerning_factor, thread_id):
+    first_fontpath, *rest = font_filepaths
+    return ft2font.FT2Font(
+        first_fontpath, hinting_factor,
+        _fallback_list=[
+            ft2font.FT2Font(
+                fpath, hinting_factor,
+                _kerning_factor=_kerning_factor
+            )
+            for fpath in rest
+        ],
+        _kerning_factor=_kerning_factor
+    )
+
+
+# FT2Font objects cannot be used across fork()s because they reference the same
+# FT_Library object.  While invalidating *all* existing FT2Fonts after a fork
+# would be too complicated to be worth it, the main way FT2Fonts get reused is
+# via the cache of _get_font, which we can empty upon forking (not on Windows,
+# which has no fork() or register_at_fork()).
+if hasattr(os, "register_at_fork"):
+    os.register_at_fork(after_in_child=_get_font.cache_clear)
+
+
+@lru_cache(64)
+def _cached_realpath(path):
+    # Resolving the path avoids embedding the font twice in pdf/ps output if a
+    # single font is selected using two different relative paths.
+    return os.path.realpath(path)
+
+
+def get_font(font_filepaths, hinting_factor=None):
+    """
+    Get an `.ft2font.FT2Font` object given a list of file paths.
+
+    Parameters
+    ----------
+    font_filepaths : Iterable[str, Path, bytes], str, Path, bytes
+        Relative or absolute paths to the font files to be used.
+
+        If a single string, bytes, or `pathlib.Path`, then it will be treated
+        as a list with that entry only.
+
+        If more than one filepath is passed, then the returned FT2Font object
+        will fall back through the fonts, in the order given, to find a needed
+        glyph.
+
+    Returns
+    -------
+    `.ft2font.FT2Font`
+
+    """
+    if isinstance(font_filepaths, (str, Path, bytes)):
+        paths = (_cached_realpath(font_filepaths),)
+    else:
+        paths = tuple(_cached_realpath(fname) for fname in font_filepaths)
+
+    if hinting_factor is None:
+        hinting_factor = mpl.rcParams['text.hinting_factor']
+
+    return _get_font(
+        # must be a tuple to be cached
+        paths,
+        hinting_factor,
+        _kerning_factor=mpl.rcParams['text.kerning_factor'],
+        # also key on the thread ID to prevent segfaults with multi-threading
+        thread_id=threading.get_ident()
+    )
+
+
+def _load_fontmanager(*, try_read_cache=True):
+    fm_path = Path(
+        mpl.get_cachedir(), f"fontlist-v{FontManager.__version__}.json")
+    if try_read_cache:
+        try:
+            fm = json_load(fm_path)
+        except Exception:
+            pass
+        else:
+            if getattr(fm, "_version", object()) == FontManager.__version__:
+                _log.debug("Using fontManager instance from %s", fm_path)
+                return fm
+    fm = FontManager()
+    json_dump(fm, fm_path)
+    _log.info("generated new fontManager")
+    return fm
+
+
+fontManager = _load_fontmanager()
+findfont = fontManager.findfont
+get_font_names = fontManager.get_font_names

infer_4_37_2/lib/python3.10/site-packages/matplotlib/inset.pyi

@@ -0,0 +1,25 @@
+from . import artist
+from .axes import Axes
+from .backend_bases import RendererBase
+from .patches import ConnectionPatch, Rectangle
+
+from .typing import ColorType, LineStyleType
+
+class InsetIndicator(artist.Artist):
+    def __init__(
+        self,
+        bounds: tuple[float, float, float, float] | None = ...,
+        inset_ax: Axes | None = ...,
+        zorder: float | None = ...,
+        **kwargs
+    ) -> None: ...
+    def set_alpha(self, alpha: float | None) -> None: ...
+    def set_edgecolor(self, color: ColorType | None) -> None: ...
+    def set_color(self, c: ColorType | None) -> None: ...
+    def set_linewidth(self, w: float | None) -> None: ...
+    def set_linestyle(self, ls: LineStyleType | None) -> None: ...
+    @property
+    def rectangle(self) -> Rectangle: ...
+    @property
+    def connectors(self) -> tuple[ConnectionPatch, ConnectionPatch, ConnectionPatch, ConnectionPatch] | None: ...
+    def draw(self, renderer: RendererBase) -> None: ...

infer_4_37_2/lib/python3.10/site-packages/matplotlib/offsetbox.pyi

@@ -0,0 +1,298 @@
+import matplotlib.artist as martist
+from matplotlib.backend_bases import RendererBase, Event, FigureCanvasBase
+from matplotlib.colors import Colormap, Normalize
+import matplotlib.text as mtext
+from matplotlib.figure import Figure, SubFigure
+from matplotlib.font_manager import FontProperties
+from matplotlib.image import BboxImage
+from matplotlib.patches import FancyArrowPatch, FancyBboxPatch
+from matplotlib.transforms import Bbox, BboxBase, Transform
+from matplotlib.typing import CoordsType
+
+import numpy as np
+from numpy.typing import ArrayLike
+from collections.abc import Callable, Sequence
+from typing import Any, Literal, overload
+
+DEBUG: bool
+
+def _get_packed_offsets(
+    widths: Sequence[float],
+    total: float | None,
+    sep: float | None,
+    mode: Literal["fixed", "expand", "equal"] = ...,
+) -> tuple[float, np.ndarray]: ...
+
+class OffsetBox(martist.Artist):
+    width: float | None
+    height: float | None
+    def __init__(self, *args, **kwargs) -> None: ...
+    def set_figure(self, fig: Figure | SubFigure) -> None: ...
+    def set_offset(
+        self,
+        xy: tuple[float, float]
+        | Callable[[float, float, float, float, RendererBase], tuple[float, float]],
+    ) -> None: ...
+
+    @overload
+    def get_offset(self, bbox: Bbox, renderer: RendererBase) -> tuple[float, float]: ...
+    @overload
+    def get_offset(
+        self,
+        width: float,
+        height: float,
+        xdescent: float,
+        ydescent: float,
+        renderer: RendererBase
+    ) -> tuple[float, float]: ...
+
+    def set_width(self, width: float) -> None: ...
+    def set_height(self, height: float) -> None: ...
+    def get_visible_children(self) -> list[martist.Artist]: ...
+    def get_children(self) -> list[martist.Artist]: ...
+    def get_bbox(self, renderer: RendererBase) -> Bbox: ...
+    def get_window_extent(self, renderer: RendererBase | None = ...) -> Bbox: ...
+
+class PackerBase(OffsetBox):
+    height: float | None
+    width: float | None
+    sep: float | None
+    pad: float | None
+    mode: Literal["fixed", "expand", "equal"]
+    align: Literal["top", "bottom", "left", "right", "center", "baseline"]
+    def __init__(
+        self,
+        pad: float | None = ...,
+        sep: float | None = ...,
+        width: float | None = ...,
+        height: float | None = ...,
+        align: Literal["top", "bottom", "left", "right", "center", "baseline"] = ...,
+        mode: Literal["fixed", "expand", "equal"] = ...,
+        children: list[martist.Artist] | None = ...,
+    ) -> None: ...
+
+class VPacker(PackerBase): ...
+class HPacker(PackerBase): ...
+
+class PaddedBox(OffsetBox):
+    pad: float | None
+    patch: FancyBboxPatch
+    def __init__(
+        self,
+        child: martist.Artist,
+        pad: float | None = ...,
+        *,
+        draw_frame: bool = ...,
+        patch_attrs: dict[str, Any] | None = ...,
+    ) -> None: ...
+    def update_frame(self, bbox: Bbox, fontsize: float | None = ...) -> None: ...
+    def draw_frame(self, renderer: RendererBase) -> None: ...
+
+class DrawingArea(OffsetBox):
+    width: float
+    height: float
+    xdescent: float
+    ydescent: float
+    offset_transform: Transform
+    dpi_transform: Transform
+    def __init__(
+        self,
+        width: float,
+        height: float,
+        xdescent: float = ...,
+        ydescent: float = ...,
+        clip: bool = ...,
+    ) -> None: ...
+    @property
+    def clip_children(self) -> bool: ...
+    @clip_children.setter
+    def clip_children(self, val: bool) -> None: ...
+    def get_transform(self) -> Transform: ...
+
+    # does not accept all options of superclass
+    def set_offset(self, xy: tuple[float, float]) -> None: ...  # type: ignore[override]
+    def get_offset(self) -> tuple[float, float]: ...  # type: ignore[override]
+    def add_artist(self, a: martist.Artist) -> None: ...
+
+class TextArea(OffsetBox):
+    offset_transform: Transform
+    def __init__(
+        self,
+        s: str,
+        *,
+        textprops: dict[str, Any] | None = ...,
+        multilinebaseline: bool = ...,
+    ) -> None: ...
+    def set_text(self, s: str) -> None: ...
+    def get_text(self) -> str: ...
+    def set_multilinebaseline(self, t: bool) -> None: ...
+    def get_multilinebaseline(self) -> bool: ...
+
+    # does not accept all options of superclass
+    def set_offset(self, xy: tuple[float, float]) -> None: ...  # type: ignore[override]
+    def get_offset(self) -> tuple[float, float]: ...  # type: ignore[override]
+
+class AuxTransformBox(OffsetBox):
+    aux_transform: Transform
+    offset_transform: Transform
+    ref_offset_transform: Transform
+    def __init__(self, aux_transform: Transform) -> None: ...
+    def add_artist(self, a: martist.Artist) -> None: ...
+    def get_transform(self) -> Transform: ...
+
+    # does not accept all options of superclass
+    def set_offset(self, xy: tuple[float, float]) -> None: ...  # type: ignore[override]
+    def get_offset(self) -> tuple[float, float]: ...  # type: ignore[override]
+
+class AnchoredOffsetbox(OffsetBox):
+    zorder: float
+    codes: dict[str, int]
+    loc: int
+    borderpad: float
+    pad: float
+    prop: FontProperties
+    patch: FancyBboxPatch
+    def __init__(
+        self,
+        loc: str,
+        *,
+        pad: float = ...,
+        borderpad: float = ...,
+        child: OffsetBox | None = ...,
+        prop: FontProperties | None = ...,
+        frameon: bool = ...,
+        bbox_to_anchor: BboxBase
+        | tuple[float, float]
+        | tuple[float, float, float, float]
+        | None = ...,
+        bbox_transform: Transform | None = ...,
+        **kwargs
+    ) -> None: ...
+    def set_child(self, child: OffsetBox | None) -> None: ...
+    def get_child(self) -> OffsetBox | None: ...
+    def get_children(self) -> list[martist.Artist]: ...
+    def get_bbox_to_anchor(self) -> Bbox: ...
+    def set_bbox_to_anchor(
+        self, bbox: BboxBase, transform: Transform | None = ...
+    ) -> None: ...
+    def update_frame(self, bbox: Bbox, fontsize: float | None = ...) -> None: ...
+
+class AnchoredText(AnchoredOffsetbox):
+    txt: TextArea
+    def __init__(
+        self,
+        s: str,
+        loc: str,
+        *,
+        pad: float = ...,
+        borderpad: float = ...,
+        prop: dict[str, Any] | None = ...,
+        **kwargs
+    ) -> None: ...
+
+class OffsetImage(OffsetBox):
+    image: BboxImage
+    def __init__(
+        self,
+        arr: ArrayLike,
+        *,
+        zoom: float = ...,
+        cmap: Colormap | str | None = ...,
+        norm: Normalize | str | None = ...,
+        interpolation: str | None = ...,
+        origin: Literal["upper", "lower"] | None = ...,
+        filternorm: bool = ...,
+        filterrad: float = ...,
+        resample: bool = ...,
+        dpi_cor: bool = ...,
+        **kwargs
+    ) -> None: ...
+    stale: bool
+    def set_data(self, arr: ArrayLike | None) -> None: ...
+    def get_data(self) -> ArrayLike | None: ...
+    def set_zoom(self, zoom: float) -> None: ...
+    def get_zoom(self) -> float: ...
+    def get_children(self) -> list[martist.Artist]: ...
+    def get_offset(self) -> tuple[float, float]: ...  # type: ignore[override]
+
+class AnnotationBbox(martist.Artist, mtext._AnnotationBase):
+    zorder: float
+    offsetbox: OffsetBox
+    arrowprops: dict[str, Any] | None
+    xybox: tuple[float, float]
+    boxcoords: CoordsType
+    arrow_patch: FancyArrowPatch | None
+    patch: FancyBboxPatch
+    prop: FontProperties
+    def __init__(
+        self,
+        offsetbox: OffsetBox,
+        xy: tuple[float, float],
+        xybox: tuple[float, float] | None = ...,
+        xycoords: CoordsType = ...,
+        boxcoords: CoordsType | None = ...,
+        *,
+        frameon: bool = ...,
+        pad: float = ...,
+        annotation_clip: bool | None = ...,
+        box_alignment: tuple[float, float] = ...,
+        bboxprops: dict[str, Any] | None = ...,
+        arrowprops: dict[str, Any] | None = ...,
+        fontsize: float | str | None = ...,
+        **kwargs
+    ) -> None: ...
+    @property
+    def xyann(self) -> tuple[float, float]: ...
+    @xyann.setter
+    def xyann(self, xyann: tuple[float, float]) -> None: ...
+    @property
+    def anncoords(
+        self,
+    ) -> CoordsType: ...
+    @anncoords.setter
+    def anncoords(
+        self,
+        coords: CoordsType,
+    ) -> None: ...
+    def get_children(self) -> list[martist.Artist]: ...
+    def set_figure(self, fig: Figure | SubFigure) -> None: ...
+    def set_fontsize(self, s: str | float | None = ...) -> None: ...
+    def get_fontsize(self) -> float: ...
+    def get_tightbbox(self, renderer: RendererBase | None = ...) -> Bbox: ...
+    def update_positions(self, renderer: RendererBase) -> None: ...
+
+class DraggableBase:
+    ref_artist: martist.Artist
+    got_artist: bool
+    mouse_x: int
+    mouse_y: int
+    background: Any
+
+    @property
+    def canvas(self) -> FigureCanvasBase: ...
+    @property
+    def cids(self) -> list[int]: ...
+
+    def __init__(self, ref_artist: martist.Artist, use_blit: bool = ...) -> None: ...
+    def on_motion(self, evt: Event) -> None: ...
+    def on_pick(self, evt: Event) -> None: ...
+    def on_release(self, event: Event) -> None: ...
+    def disconnect(self) -> None: ...
+    def save_offset(self) -> None: ...
+    def update_offset(self, dx: float, dy: float) -> None: ...
+    def finalize_offset(self) -> None: ...
+
+class DraggableOffsetBox(DraggableBase):
+    offsetbox: OffsetBox
+    def __init__(
+        self, ref_artist: martist.Artist, offsetbox: OffsetBox, use_blit: bool = ...
+    ) -> None: ...
+    def save_offset(self) -> None: ...
+    def update_offset(self, dx: float, dy: float) -> None: ...
+    def get_loc_in_canvas(self) -> tuple[float, float]: ...
+
+class DraggableAnnotation(DraggableBase):
+    annotation: mtext.Annotation
+    def __init__(self, annotation: mtext.Annotation, use_blit: bool = ...) -> None: ...
+    def save_offset(self) -> None: ...
+    def update_offset(self, dx: float, dy: float) -> None: ...

infer_4_37_2/lib/python3.10/site-packages/matplotlib/pylab.py

@@ -0,0 +1,67 @@
+"""
+`pylab` is a historic interface and its use is strongly discouraged. The equivalent
+replacement is `matplotlib.pyplot`.  See :ref:`api_interfaces` for a full overview
+of Matplotlib interfaces.
+
+`pylab` was designed to support a MATLAB-like way of working with all plotting related
+functions directly available in the global namespace. This was achieved through a
+wildcard import (``from pylab import *``).
+
+.. warning::
+   The use of `pylab` is discouraged for the following reasons:
+
+   ``from pylab import *`` imports all the functions from `matplotlib.pyplot`, `numpy`,
+   `numpy.fft`, `numpy.linalg`, and `numpy.random`, and some additional functions into
+   the global namespace.
+
+   Such a pattern is considered bad practice in modern python, as it clutters the global
+   namespace. Even more severely, in the case of `pylab`, this will overwrite some
+   builtin functions (e.g. the builtin `sum` will be replaced by `numpy.sum`), which
+   can lead to unexpected behavior.
+
+"""
+
+from matplotlib.cbook import flatten, silent_list
+
+import matplotlib as mpl
+
+from matplotlib.dates import (
+    date2num, num2date, datestr2num, drange, DateFormatter, DateLocator,
+    RRuleLocator, YearLocator, MonthLocator, WeekdayLocator, DayLocator,
+    HourLocator, MinuteLocator, SecondLocator, rrule, MO, TU, WE, TH, FR,
+    SA, SU, YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY, SECONDLY,
+    relativedelta)
+
+# bring all the symbols in so folks can import them from
+# pylab in one fell swoop
+
+## We are still importing too many things from mlab; more cleanup is needed.
+
+from matplotlib.mlab import (
+    detrend, detrend_linear, detrend_mean, detrend_none, window_hanning,
+    window_none)
+
+from matplotlib import cbook, mlab, pyplot as plt
+from matplotlib.pyplot import *
+
+from numpy import *
+from numpy.fft import *
+from numpy.random import *
+from numpy.linalg import *
+
+import numpy as np
+import numpy.ma as ma
+
+# don't let numpy's datetime hide stdlib
+import datetime
+
+# This is needed, or bytes will be numpy.random.bytes from
+# "from numpy.random import *" above
+bytes = __import__("builtins").bytes
+# We also don't want the numpy version of these functions
+abs = __import__("builtins").abs
+bool = __import__("builtins").bool
+max = __import__("builtins").max
+min = __import__("builtins").min
+pow = __import__("builtins").pow
+round = __import__("builtins").round

infer_4_37_2/lib/python3.10/site-packages/matplotlib/texmanager.pyi

@@ -0,0 +1,38 @@
+from .backend_bases import RendererBase
+
+from matplotlib.typing import ColorType
+
+import numpy as np
+
+class TexManager:
+    texcache: str
+    @classmethod
+    def get_basefile(
+        cls, tex: str, fontsize: float, dpi: float | None = ...
+    ) -> str: ...
+    @classmethod
+    def get_font_preamble(cls) -> str: ...
+    @classmethod
+    def get_custom_preamble(cls) -> str: ...
+    @classmethod
+    def make_tex(cls, tex: str, fontsize: float) -> str: ...
+    @classmethod
+    def make_dvi(cls, tex: str, fontsize: float) -> str: ...
+    @classmethod
+    def make_png(cls, tex: str, fontsize: float, dpi: float) -> str: ...
+    @classmethod
+    def get_grey(
+        cls, tex: str, fontsize: float | None = ..., dpi: float | None = ...
+    ) -> np.ndarray: ...
+    @classmethod
+    def get_rgba(
+        cls,
+        tex: str,
+        fontsize: float | None = ...,
+        dpi: float | None = ...,
+        rgb: ColorType = ...,
+    ) -> np.ndarray: ...
+    @classmethod
+    def get_text_width_height_descent(
+        cls, tex: str, fontsize, renderer: RendererBase | None = ...
+    ) -> tuple[int, int, int]: ...

infer_4_37_2/lib/python3.10/site-packages/matplotlib/ticker.pyi

@@ -0,0 +1,297 @@
+from collections.abc import Callable, Sequence
+from typing import Any, Literal
+
+from matplotlib.axis import Axis
+from matplotlib.transforms import Transform
+from matplotlib.projections.polar import _AxisWrapper
+
+import numpy as np
+
+class _DummyAxis:
+    __name__: str
+    def __init__(self, minpos: float = ...) -> None: ...
+    def get_view_interval(self) -> tuple[float, float]: ...
+    def set_view_interval(self, vmin: float, vmax: float) -> None: ...
+    def get_minpos(self) -> float: ...
+    def get_data_interval(self) -> tuple[float, float]: ...
+    def set_data_interval(self, vmin: float, vmax: float) -> None: ...
+    def get_tick_space(self) -> int: ...
+
+class TickHelper:
+    axis: None | Axis | _DummyAxis | _AxisWrapper
+    def set_axis(self, axis: Axis | _DummyAxis | _AxisWrapper | None) -> None: ...
+    def create_dummy_axis(self, **kwargs) -> None: ...
+
+class Formatter(TickHelper):
+    locs: list[float]
+    def __call__(self, x: float, pos: int | None = ...) -> str: ...
+    def format_ticks(self, values: list[float]) -> list[str]: ...
+    def format_data(self, value: float) -> str: ...
+    def format_data_short(self, value: float) -> str: ...
+    def get_offset(self) -> str: ...
+    def set_locs(self, locs: list[float]) -> None: ...
+    @staticmethod
+    def fix_minus(s: str) -> str: ...
+
+class NullFormatter(Formatter): ...
+
+class FixedFormatter(Formatter):
+    seq: Sequence[str]
+    offset_string: str
+    def __init__(self, seq: Sequence[str]) -> None: ...
+    def set_offset_string(self, ofs: str) -> None: ...
+
+class FuncFormatter(Formatter):
+    func: Callable[[float, int | None], str]
+    offset_string: str
+    # Callable[[float, int | None], str] | Callable[[float], str]
+    def __init__(self, func: Callable[..., str]) -> None: ...
+    def set_offset_string(self, ofs: str) -> None: ...
+
+class FormatStrFormatter(Formatter):
+    fmt: str
+    def __init__(self, fmt: str) -> None: ...
+
+class StrMethodFormatter(Formatter):
+    fmt: str
+    def __init__(self, fmt: str) -> None: ...
+
+class ScalarFormatter(Formatter):
+    orderOfMagnitude: int
+    format: str
+    def __init__(
+        self,
+        useOffset: bool | float | None = ...,
+        useMathText: bool | None = ...,
+        useLocale: bool | None = ...,
+        *,
+        usetex: bool | None = ...,
+    ) -> None: ...
+    offset: float
+    def get_usetex(self) -> bool: ...
+    def set_usetex(self, val: bool) -> None: ...
+    @property
+    def usetex(self) -> bool: ...
+    @usetex.setter
+    def usetex(self, val: bool) -> None: ...
+    def get_useOffset(self) -> bool: ...
+    def set_useOffset(self, val: bool | float) -> None: ...
+    @property
+    def useOffset(self) -> bool: ...
+    @useOffset.setter
+    def useOffset(self, val: bool | float) -> None: ...
+    def get_useLocale(self) -> bool: ...
+    def set_useLocale(self, val: bool | None) -> None: ...
+    @property
+    def useLocale(self) -> bool: ...
+    @useLocale.setter
+    def useLocale(self, val: bool | None) -> None: ...
+    def get_useMathText(self) -> bool: ...
+    def set_useMathText(self, val: bool | None) -> None: ...
+    @property
+    def useMathText(self) -> bool: ...
+    @useMathText.setter
+    def useMathText(self, val: bool | None) -> None: ...
+    def set_scientific(self, b: bool) -> None: ...
+    def set_powerlimits(self, lims: tuple[int, int]) -> None: ...
+    def format_data_short(self, value: float | np.ma.MaskedArray) -> str: ...
+    def format_data(self, value: float) -> str: ...
+
+class LogFormatter(Formatter):
+    minor_thresholds: tuple[float, float]
+    def __init__(
+        self,
+        base: float = ...,
+        labelOnlyBase: bool = ...,
+        minor_thresholds: tuple[float, float] | None = ...,
+        linthresh: float | None = ...,
+    ) -> None: ...
+    def set_base(self, base: float) -> None: ...
+    labelOnlyBase: bool
+    def set_label_minor(self, labelOnlyBase: bool) -> None: ...
+    def set_locs(self, locs: Any | None = ...) -> None: ...
+    def format_data(self, value: float) -> str: ...
+    def format_data_short(self, value: float) -> str: ...
+
+class LogFormatterExponent(LogFormatter): ...
+class LogFormatterMathtext(LogFormatter): ...
+class LogFormatterSciNotation(LogFormatterMathtext): ...
+
+class LogitFormatter(Formatter):
+    def __init__(
+        self,
+        *,
+        use_overline: bool = ...,
+        one_half: str = ...,
+        minor: bool = ...,
+        minor_threshold: int = ...,
+        minor_number: int = ...
+    ) -> None: ...
+    def use_overline(self, use_overline: bool) -> None: ...
+    def set_one_half(self, one_half: str) -> None: ...
+    def set_minor_threshold(self, minor_threshold: int) -> None: ...
+    def set_minor_number(self, minor_number: int) -> None: ...
+    def format_data_short(self, value: float) -> str: ...
+
+class EngFormatter(ScalarFormatter):
+    ENG_PREFIXES: dict[int, str]
+    unit: str
+    places: int | None
+    sep: str
+    def __init__(
+        self,
+        unit: str = ...,
+        places: int | None = ...,
+        sep: str = ...,
+        *,
+        usetex: bool | None = ...,
+        useMathText: bool | None = ...,
+        useOffset: bool | float | None = ...,
+    ) -> None: ...
+    def format_eng(self, num: float) -> str: ...
+
+class PercentFormatter(Formatter):
+    xmax: float
+    decimals: int | None
+    def __init__(
+        self,
+        xmax: float = ...,
+        decimals: int | None = ...,
+        symbol: str | None = ...,
+        is_latex: bool = ...,
+    ) -> None: ...
+    def format_pct(self, x: float, display_range: float) -> str: ...
+    def convert_to_pct(self, x: float) -> float: ...
+    @property
+    def symbol(self) -> str: ...
+    @symbol.setter
+    def symbol(self, symbol: str) -> None: ...
+
+class Locator(TickHelper):
+    MAXTICKS: int
+    def tick_values(self, vmin: float, vmax: float) -> Sequence[float]: ...
+    # Implementation accepts **kwargs, but is a no-op other than a warning
+    # Typing as **kwargs would require each subclass to accept **kwargs for mypy
+    def set_params(self) -> None: ...
+    def __call__(self) -> Sequence[float]: ...
+    def raise_if_exceeds(self, locs: Sequence[float]) -> Sequence[float]: ...
+    def nonsingular(self, v0: float, v1: float) -> tuple[float, float]: ...
+    def view_limits(self, vmin: float, vmax: float) -> tuple[float, float]: ...
+
+class IndexLocator(Locator):
+    offset: float
+    def __init__(self, base: float, offset: float) -> None: ...
+    def set_params(
+        self, base: float | None = ..., offset: float | None = ...
+    ) -> None: ...
+
+class FixedLocator(Locator):
+    nbins: int | None
+    def __init__(self, locs: Sequence[float], nbins: int | None = ...) -> None: ...
+    def set_params(self, nbins: int | None = ...) -> None: ...
+
+class NullLocator(Locator): ...
+
+class LinearLocator(Locator):
+    presets: dict[tuple[float, float], Sequence[float]]
+    def __init__(
+        self,
+        numticks: int | None = ...,
+        presets: dict[tuple[float, float], Sequence[float]] | None = ...,
+    ) -> None: ...
+    @property
+    def numticks(self) -> int: ...
+    @numticks.setter
+    def numticks(self, numticks: int | None) -> None: ...
+    def set_params(
+        self,
+        numticks: int | None = ...,
+        presets: dict[tuple[float, float], Sequence[float]] | None = ...,
+    ) -> None: ...
+
+class MultipleLocator(Locator):
+    def __init__(self, base: float = ..., offset: float = ...) -> None: ...
+    def set_params(self, base: float | None = ..., offset: float | None = ...) -> None: ...
+    def view_limits(self, dmin: float, dmax: float) -> tuple[float, float]: ...
+
+class _Edge_integer:
+    step: float
+    def __init__(self, step: float, offset: float) -> None: ...
+    def closeto(self, ms: float, edge: float) -> bool: ...
+    def le(self, x: float) -> float: ...
+    def ge(self, x: float) -> float: ...
+
+class MaxNLocator(Locator):
+    default_params: dict[str, Any]
+    def __init__(self, nbins: int | Literal["auto"] | None = ..., **kwargs) -> None: ...
+    def set_params(self, **kwargs) -> None: ...
+    def view_limits(self, dmin: float, dmax: float) -> tuple[float, float]: ...
+
+class LogLocator(Locator):
+    numticks: int | None
+    def __init__(
+        self,
+        base: float = ...,
+        subs: None | Literal["auto", "all"] | Sequence[float] = ...,
+        *,
+        numticks: int | None = ...,
+    ) -> None: ...
+    def set_params(
+        self,
+        base: float | None = ...,
+        subs: Literal["auto", "all"] | Sequence[float] | None = ...,
+        *,
+        numticks: int | None = ...,
+    ) -> None: ...
+
+class SymmetricalLogLocator(Locator):
+    numticks: int
+    def __init__(
+        self,
+        transform: Transform | None = ...,
+        subs: Sequence[float] | None = ...,
+        linthresh: float | None = ...,
+        base: float | None = ...,
+    ) -> None: ...
+    def set_params(
+        self, subs: Sequence[float] | None = ..., numticks: int | None = ...
+    ) -> None: ...
+
+class AsinhLocator(Locator):
+    linear_width: float
+    numticks: int
+    symthresh: float
+    base: int
+    subs: Sequence[float] | None
+    def __init__(
+        self,
+        linear_width: float,
+        numticks: int = ...,
+        symthresh: float = ...,
+        base: int = ...,
+        subs: Sequence[float] | None = ...,
+    ) -> None: ...
+    def set_params(
+        self,
+        numticks: int | None = ...,
+        symthresh: float | None = ...,
+        base: int | None = ...,
+        subs: Sequence[float] | None = ...,
+    ) -> None: ...
+
+class LogitLocator(MaxNLocator):
+    def __init__(
+        self, minor: bool = ..., *, nbins: Literal["auto"] | int = ...
+    ) -> None: ...
+    def set_params(self, minor: bool | None = ..., **kwargs) -> None: ...
+    @property
+    def minor(self) -> bool: ...
+    @minor.setter
+    def minor(self, value: bool) -> None: ...
+
+class AutoLocator(MaxNLocator):
+    def __init__(self) -> None: ...
+
+class AutoMinorLocator(Locator):
+    ndivs: int
+    def __init__(self, n: int | None = ...) -> None: ...

infer_4_37_2/lib/python3.10/site-packages/pkg_resources/tests/data/my-test-package-source/setup.py

@@ -0,0 +1,7 @@
+import setuptools
+
+setuptools.setup(
+    name="my-test-package",
+    version="1.0",
+    zip_safe=True,
+)

infer_4_37_2/lib/python3.10/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 1.0
+Name: my-test-package
+Version: 1.0
+Summary: UNKNOWN
+Home-page: UNKNOWN
+Author: UNKNOWN
+Author-email: UNKNOWN
+License: UNKNOWN
+Description: UNKNOWN
+Platform: UNKNOWN

infer_4_37_2/lib/python3.10/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/SOURCES.txt

@@ -0,0 +1,7 @@
+setup.cfg
+setup.py
+my_test_package.egg-info/PKG-INFO
+my_test_package.egg-info/SOURCES.txt
+my_test_package.egg-info/dependency_links.txt
+my_test_package.egg-info/top_level.txt
+my_test_package.egg-info/zip-safe

infer_4_37_2/lib/python3.10/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/dependency_links.txt

@@ -0,0 +1 @@
+

infer_4_37_2/lib/python3.10/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/top_level.txt

@@ -0,0 +1 @@
+

infer_4_37_2/lib/python3.10/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/zip-safe

@@ -0,0 +1 @@
+

infer_4_37_2/lib/python3.10/site-packages/pkg_resources/tests/test_working_set.py

@@ -0,0 +1,501 @@
+import functools
+import inspect
+import re
+import textwrap
+
+import pytest
+
+import pkg_resources
+
+from .test_resources import Metadata
+
+
+def strip_comments(s):
+    return '\n'.join(
+        line
+        for line in s.split('\n')
+        if line.strip() and not line.strip().startswith('#')
+    )
+
+
+def parse_distributions(s):
+    """
+    Parse a series of distribution specs of the form:
+    {project_name}-{version}
+       [optional, indented requirements specification]
+
+    Example:
+
+        foo-0.2
+        bar-1.0
+          foo>=3.0
+          [feature]
+          baz
+
+    yield 2 distributions:
+        - project_name=foo, version=0.2
+        - project_name=bar, version=1.0,
+          requires=['foo>=3.0', 'baz; extra=="feature"']
+    """
+    s = s.strip()
+    for spec in re.split(r'\n(?=[^\s])', s):
+        if not spec:
+            continue
+        fields = spec.split('\n', 1)
+        assert 1 <= len(fields) <= 2
+        name, version = fields.pop(0).rsplit('-', 1)
+        if fields:
+            requires = textwrap.dedent(fields.pop(0))
+            metadata = Metadata(('requires.txt', requires))
+        else:
+            metadata = None
+        dist = pkg_resources.Distribution(
+            project_name=name, version=version, metadata=metadata
+        )
+        yield dist
+
+
+class FakeInstaller:
+    def __init__(self, installable_dists) -> None:
+        self._installable_dists = installable_dists
+
+    def __call__(self, req):
+        return next(
+            iter(filter(lambda dist: dist in req, self._installable_dists)), None
+        )
+
+
+def parametrize_test_working_set_resolve(*test_list):
+    idlist = []
+    argvalues = []
+    for test in test_list:
+        (
+            name,
+            installed_dists,
+            installable_dists,
+            requirements,
+            expected1,
+            expected2,
+        ) = (
+            strip_comments(s.lstrip())
+            for s in textwrap.dedent(test).lstrip().split('\n\n', 5)
+        )
+        installed_dists = list(parse_distributions(installed_dists))
+        installable_dists = list(parse_distributions(installable_dists))
+        requirements = list(pkg_resources.parse_requirements(requirements))
+        for id_, replace_conflicting, expected in (
+            (name, False, expected1),
+            (name + '_replace_conflicting', True, expected2),
+        ):
+            idlist.append(id_)
+            expected = strip_comments(expected.strip())
+            if re.match(r'\w+$', expected):
+                expected = getattr(pkg_resources, expected)
+                assert issubclass(expected, Exception)
+            else:
+                expected = list(parse_distributions(expected))
+            argvalues.append(
+                pytest.param(
+                    installed_dists,
+                    installable_dists,
+                    requirements,
+                    replace_conflicting,
+                    expected,
+                )
+            )
+    return pytest.mark.parametrize(
+        'installed_dists,installable_dists,'
+        'requirements,replace_conflicting,'
+        'resolved_dists_or_exception',
+        argvalues,
+        ids=idlist,
+    )
+
+
+@parametrize_test_working_set_resolve(
+    """
+    # id
+    noop
+
+    # installed
+
+    # installable
+
+    # wanted
+
+    # resolved
+
+    # resolved [replace conflicting]
+    """,
+    """
+    # id
+    already_installed
+
+    # installed
+    foo-3.0
+
+    # installable
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+
+    # resolved
+    foo-3.0
+
+    # resolved [replace conflicting]
+    foo-3.0
+    """,
+    """
+    # id
+    installable_not_installed
+
+    # installed
+
+    # installable
+    foo-3.0
+    foo-4.0
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+
+    # resolved
+    foo-3.0
+
+    # resolved [replace conflicting]
+    foo-3.0
+    """,
+    """
+    # id
+    not_installable
+
+    # installed
+
+    # installable
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+
+    # resolved
+    DistributionNotFound
+
+    # resolved [replace conflicting]
+    DistributionNotFound
+    """,
+    """
+    # id
+    no_matching_version
+
+    # installed
+
+    # installable
+    foo-3.1
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+
+    # resolved
+    DistributionNotFound
+
+    # resolved [replace conflicting]
+    DistributionNotFound
+    """,
+    """
+    # id
+    installable_with_installed_conflict
+
+    # installed
+    foo-3.1
+
+    # installable
+    foo-3.5
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    foo-3.5
+    """,
+    """
+    # id
+    not_installable_with_installed_conflict
+
+    # installed
+    foo-3.1
+
+    # installable
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    DistributionNotFound
+    """,
+    """
+    # id
+    installed_with_installed_require
+
+    # installed
+    foo-3.9
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # installable
+
+    # wanted
+    baz
+
+    # resolved
+    foo-3.9
+    baz-0.1
+
+    # resolved [replace conflicting]
+    foo-3.9
+    baz-0.1
+    """,
+    """
+    # id
+    installed_with_conflicting_installed_require
+
+    # installed
+    foo-5
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # installable
+
+    # wanted
+    baz
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    DistributionNotFound
+    """,
+    """
+    # id
+    installed_with_installable_conflicting_require
+
+    # installed
+    foo-5
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # installable
+    foo-2.9
+
+    # wanted
+    baz
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    baz-0.1
+    foo-2.9
+    """,
+    """
+    # id
+    installed_with_installable_require
+
+    # installed
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # installable
+    foo-3.9
+
+    # wanted
+    baz
+
+    # resolved
+    foo-3.9
+    baz-0.1
+
+    # resolved [replace conflicting]
+    foo-3.9
+    baz-0.1
+    """,
+    """
+    # id
+    installable_with_installed_require
+
+    # installed
+    foo-3.9
+
+    # installable
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # wanted
+    baz
+
+    # resolved
+    foo-3.9
+    baz-0.1
+
+    # resolved [replace conflicting]
+    foo-3.9
+    baz-0.1
+    """,
+    """
+    # id
+    installable_with_installable_require
+
+    # installed
+
+    # installable
+    foo-3.9
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # wanted
+    baz
+
+    # resolved
+    foo-3.9
+    baz-0.1
+
+    # resolved [replace conflicting]
+    foo-3.9
+    baz-0.1
+    """,
+    """
+    # id
+    installable_with_conflicting_installable_require
+
+    # installed
+    foo-5
+
+    # installable
+    foo-2.9
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # wanted
+    baz
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    baz-0.1
+    foo-2.9
+    """,
+    """
+    # id
+    conflicting_installables
+
+    # installed
+
+    # installable
+    foo-2.9
+    foo-5.0
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+    foo>=4
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    VersionConflict
+    """,
+    """
+    # id
+    installables_with_conflicting_requires
+
+    # installed
+
+    # installable
+    foo-2.9
+        dep==1.0
+    baz-5.0
+        dep==2.0
+    dep-1.0
+    dep-2.0
+
+    # wanted
+    foo
+    baz
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    VersionConflict
+    """,
+    """
+    # id
+    installables_with_conflicting_nested_requires
+
+    # installed
+
+    # installable
+    foo-2.9
+        dep1
+    dep1-1.0
+        subdep<1.0
+    baz-5.0
+        dep2
+    dep2-1.0
+        subdep>1.0
+    subdep-0.9
+    subdep-1.1
+
+    # wanted
+    foo
+    baz
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    VersionConflict
+    """,
+    """
+    # id
+    wanted_normalized_name_installed_canonical
+
+    # installed
+    foo.bar-3.6
+
+    # installable
+
+    # wanted
+    foo-bar==3.6
+
+    # resolved
+    foo.bar-3.6
+
+    # resolved [replace conflicting]
+    foo.bar-3.6
+    """,
+)
+def test_working_set_resolve(
+    installed_dists,
+    installable_dists,
+    requirements,
+    replace_conflicting,
+    resolved_dists_or_exception,
+):
+    ws = pkg_resources.WorkingSet([])
+    list(map(ws.add, installed_dists))
+    resolve_call = functools.partial(
+        ws.resolve,
+        requirements,
+        installer=FakeInstaller(installable_dists),
+        replace_conflicting=replace_conflicting,
+    )
+    if inspect.isclass(resolved_dists_or_exception):
+        with pytest.raises(resolved_dists_or_exception):
+            resolve_call()
+    else:
+        assert sorted(resolve_call()) == sorted(resolved_dists_or_exception)

infer_4_37_2/lib/python3.10/site-packages/prometheus_client-0.21.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

infer_4_37_2/lib/python3.10/site-packages/prometheus_client-0.21.1.dist-info/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.