Add files using upload-large-folder tool

.gitattributes

@@ -1006,3 +1006,4 @@ infer_4_30_0/lib/python3.10/site-packages/scipy/stats/__pycache__/_mstats_basic.
 infer_4_30_0/lib/python3.10/site-packages/scipy/stats/__pycache__/_distribution_infrastructure.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 infer_4_30_0/lib/python3.10/site-packages/scipy/signal/_peak_finding_utils.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 infer_4_30_0/lib/python3.10/site-packages/scipy/signal/_upfirdn_apply.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pkg_resources/__pycache__/__init__.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

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

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

@@ -0,0 +1,532 @@
+"""
+A python interface to Adobe Font Metrics Files.
+
+Although a number of other Python implementations exist, and may be more
+complete than this, it was decided not to go with them because they were
+either:
+
+1) copyrighted or used a non-BSD compatible license
+2) had too many dependencies and a free standing lib was needed
+3) did more than needed and it was easier to write afresh rather than
+   figure out how to get just what was needed.
+
+It is pretty easy to use, and has no external dependencies:
+
+>>> import matplotlib as mpl
+>>> from pathlib import Path
+>>> afm_path = Path(mpl.get_data_path(), 'fonts', 'afm', 'ptmr8a.afm')
+>>>
+>>> from matplotlib.afm import AFM
+>>> with afm_path.open('rb') as fh:
+...     afm = AFM(fh)
+>>> afm.string_width_height('What the heck?')
+(6220.0, 694)
+>>> afm.get_fontname()
+'Times-Roman'
+>>> afm.get_kern_dist('A', 'f')
+0
+>>> afm.get_kern_dist('A', 'y')
+-92.0
+>>> afm.get_bbox_char('!')
+[130, -9, 238, 676]
+
+As in the Adobe Font Metrics File Format Specification, all dimensions
+are given in units of 1/1000 of the scale factor (point size) of the font
+being used.
+"""
+
+from collections import namedtuple
+import logging
+import re
+
+from ._mathtext_data import uni2type1
+
+
+_log = logging.getLogger(__name__)
+
+
+def _to_int(x):
+    # Some AFM files have floats where we are expecting ints -- there is
+    # probably a better way to handle this (support floats, round rather than
+    # truncate).  But I don't know what the best approach is now and this
+    # change to _to_int should at least prevent Matplotlib from crashing on
+    # these.  JDH (2009-11-06)
+    return int(float(x))
+
+
+def _to_float(x):
+    # Some AFM files use "," instead of "." as decimal separator -- this
+    # shouldn't be ambiguous (unless someone is wicked enough to use "," as
+    # thousands separator...).
+    if isinstance(x, bytes):
+        # Encoding doesn't really matter -- if we have codepoints >127 the call
+        # to float() will error anyways.
+        x = x.decode('latin-1')
+    return float(x.replace(',', '.'))
+
+
+def _to_str(x):
+    return x.decode('utf8')
+
+
+def _to_list_of_ints(s):
+    s = s.replace(b',', b' ')
+    return [_to_int(val) for val in s.split()]
+
+
+def _to_list_of_floats(s):
+    return [_to_float(val) for val in s.split()]
+
+
+def _to_bool(s):
+    if s.lower().strip() in (b'false', b'0', b'no'):
+        return False
+    else:
+        return True
+
+
+def _parse_header(fh):
+    """
+    Read the font metrics header (up to the char metrics) and returns
+    a dictionary mapping *key* to *val*.  *val* will be converted to the
+    appropriate python type as necessary; e.g.:
+
+        * 'False'->False
+        * '0'->0
+        * '-168 -218 1000 898'-> [-168, -218, 1000, 898]
+
+    Dictionary keys are
+
+      StartFontMetrics, FontName, FullName, FamilyName, Weight,
+      ItalicAngle, IsFixedPitch, FontBBox, UnderlinePosition,
+      UnderlineThickness, Version, Notice, EncodingScheme, CapHeight,
+      XHeight, Ascender, Descender, StartCharMetrics
+    """
+    header_converters = {
+        b'StartFontMetrics': _to_float,
+        b'FontName': _to_str,
+        b'FullName': _to_str,
+        b'FamilyName': _to_str,
+        b'Weight': _to_str,
+        b'ItalicAngle': _to_float,
+        b'IsFixedPitch': _to_bool,
+        b'FontBBox': _to_list_of_ints,
+        b'UnderlinePosition': _to_float,
+        b'UnderlineThickness': _to_float,
+        b'Version': _to_str,
+        # Some AFM files have non-ASCII characters (which are not allowed by
+        # the spec).  Given that there is actually no public API to even access
+        # this field, just return it as straight bytes.
+        b'Notice': lambda x: x,
+        b'EncodingScheme': _to_str,
+        b'CapHeight': _to_float,  # Is the second version a mistake, or
+        b'Capheight': _to_float,  # do some AFM files contain 'Capheight'? -JKS
+        b'XHeight': _to_float,
+        b'Ascender': _to_float,
+        b'Descender': _to_float,
+        b'StdHW': _to_float,
+        b'StdVW': _to_float,
+        b'StartCharMetrics': _to_int,
+        b'CharacterSet': _to_str,
+        b'Characters': _to_int,
+    }
+    d = {}
+    first_line = True
+    for line in fh:
+        line = line.rstrip()
+        if line.startswith(b'Comment'):
+            continue
+        lst = line.split(b' ', 1)
+        key = lst[0]
+        if first_line:
+            # AFM spec, Section 4: The StartFontMetrics keyword
+            # [followed by a version number] must be the first line in
+            # the file, and the EndFontMetrics keyword must be the
+            # last non-empty line in the file.  We just check the
+            # first header entry.
+            if key != b'StartFontMetrics':
+                raise RuntimeError('Not an AFM file')
+            first_line = False
+        if len(lst) == 2:
+            val = lst[1]
+        else:
+            val = b''
+        try:
+            converter = header_converters[key]
+        except KeyError:
+            _log.error("Found an unknown keyword in AFM header (was %r)", key)
+            continue
+        try:
+            d[key] = converter(val)
+        except ValueError:
+            _log.error('Value error parsing header in AFM: %s, %s', key, val)
+            continue
+        if key == b'StartCharMetrics':
+            break
+    else:
+        raise RuntimeError('Bad parse')
+    return d
+
+
+CharMetrics = namedtuple('CharMetrics', 'width, name, bbox')
+CharMetrics.__doc__ = """
+    Represents the character metrics of a single character.
+
+    Notes
+    -----
+    The fields do currently only describe a subset of character metrics
+    information defined in the AFM standard.
+    """
+CharMetrics.width.__doc__ = """The character width (WX)."""
+CharMetrics.name.__doc__ = """The character name (N)."""
+CharMetrics.bbox.__doc__ = """
+    The bbox of the character (B) as a tuple (*llx*, *lly*, *urx*, *ury*)."""
+
+
+def _parse_char_metrics(fh):
+    """
+    Parse the given filehandle for character metrics information and return
+    the information as dicts.
+
+    It is assumed that the file cursor is on the line behind
+    'StartCharMetrics'.
+
+    Returns
+    -------
+    ascii_d : dict
+         A mapping "ASCII num of the character" to `.CharMetrics`.
+    name_d : dict
+         A mapping "character name" to `.CharMetrics`.
+
+    Notes
+    -----
+    This function is incomplete per the standard, but thus far parses
+    all the sample afm files tried.
+    """
+    required_keys = {'C', 'WX', 'N', 'B'}
+
+    ascii_d = {}
+    name_d = {}
+    for line in fh:
+        # We are defensively letting values be utf8. The spec requires
+        # ascii, but there are non-compliant fonts in circulation
+        line = _to_str(line.rstrip())  # Convert from byte-literal
+        if line.startswith('EndCharMetrics'):
+            return ascii_d, name_d
+        # Split the metric line into a dictionary, keyed by metric identifiers
+        vals = dict(s.strip().split(' ', 1) for s in line.split(';') if s)
+        # There may be other metrics present, but only these are needed
+        if not required_keys.issubset(vals):
+            raise RuntimeError('Bad char metrics line: %s' % line)
+        num = _to_int(vals['C'])
+        wx = _to_float(vals['WX'])
+        name = vals['N']
+        bbox = _to_list_of_floats(vals['B'])
+        bbox = list(map(int, bbox))
+        metrics = CharMetrics(wx, name, bbox)
+        # Workaround: If the character name is 'Euro', give it the
+        # corresponding character code, according to WinAnsiEncoding (see PDF
+        # Reference).
+        if name == 'Euro':
+            num = 128
+        elif name == 'minus':
+            num = ord("\N{MINUS SIGN}")  # 0x2212
+        if num != -1:
+            ascii_d[num] = metrics
+        name_d[name] = metrics
+    raise RuntimeError('Bad parse')
+
+
+def _parse_kern_pairs(fh):
+    """
+    Return a kern pairs dictionary; keys are (*char1*, *char2*) tuples and
+    values are the kern pair value.  For example, a kern pairs line like
+    ``KPX A y -50``
+
+    will be represented as::
+
+      d[ ('A', 'y') ] = -50
+
+    """
+
+    line = next(fh)
+    if not line.startswith(b'StartKernPairs'):
+        raise RuntimeError('Bad start of kern pairs data: %s' % line)
+
+    d = {}
+    for line in fh:
+        line = line.rstrip()
+        if not line:
+            continue
+        if line.startswith(b'EndKernPairs'):
+            next(fh)  # EndKernData
+            return d
+        vals = line.split()
+        if len(vals) != 4 or vals[0] != b'KPX':
+            raise RuntimeError('Bad kern pairs line: %s' % line)
+        c1, c2, val = _to_str(vals[1]), _to_str(vals[2]), _to_float(vals[3])
+        d[(c1, c2)] = val
+    raise RuntimeError('Bad kern pairs parse')
+
+
+CompositePart = namedtuple('CompositePart', 'name, dx, dy')
+CompositePart.__doc__ = """
+    Represents the information on a composite element of a composite char."""
+CompositePart.name.__doc__ = """Name of the part, e.g. 'acute'."""
+CompositePart.dx.__doc__ = """x-displacement of the part from the origin."""
+CompositePart.dy.__doc__ = """y-displacement of the part from the origin."""
+
+
+def _parse_composites(fh):
+    """
+    Parse the given filehandle for composites information return them as a
+    dict.
+
+    It is assumed that the file cursor is on the line behind 'StartComposites'.
+
+    Returns
+    -------
+    dict
+        A dict mapping composite character names to a parts list. The parts
+        list is a list of `.CompositePart` entries describing the parts of
+        the composite.
+
+    Examples
+    --------
+    A composite definition line::
+
+      CC Aacute 2 ; PCC A 0 0 ; PCC acute 160 170 ;
+
+    will be represented as::
+
+      composites['Aacute'] = [CompositePart(name='A', dx=0, dy=0),
+                              CompositePart(name='acute', dx=160, dy=170)]
+
+    """
+    composites = {}
+    for line in fh:
+        line = line.rstrip()
+        if not line:
+            continue
+        if line.startswith(b'EndComposites'):
+            return composites
+        vals = line.split(b';')
+        cc = vals[0].split()
+        name, _num_parts = cc[1], _to_int(cc[2])
+        pccParts = []
+        for s in vals[1:-1]:
+            pcc = s.split()
+            part = CompositePart(pcc[1], _to_float(pcc[2]), _to_float(pcc[3]))
+            pccParts.append(part)
+        composites[name] = pccParts
+
+    raise RuntimeError('Bad composites parse')
+
+
+def _parse_optional(fh):
+    """
+    Parse the optional fields for kern pair data and composites.
+
+    Returns
+    -------
+    kern_data : dict
+        A dict containing kerning information. May be empty.
+        See `._parse_kern_pairs`.
+    composites : dict
+        A dict containing composite information. May be empty.
+        See `._parse_composites`.
+    """
+    optional = {
+        b'StartKernData': _parse_kern_pairs,
+        b'StartComposites':  _parse_composites,
+        }
+
+    d = {b'StartKernData': {},
+         b'StartComposites': {}}
+    for line in fh:
+        line = line.rstrip()
+        if not line:
+            continue
+        key = line.split()[0]
+
+        if key in optional:
+            d[key] = optional[key](fh)
+
+    return d[b'StartKernData'], d[b'StartComposites']
+
+
+class AFM:
+
+    def __init__(self, fh):
+        """Parse the AFM file in file object *fh*."""
+        self._header = _parse_header(fh)
+        self._metrics, self._metrics_by_name = _parse_char_metrics(fh)
+        self._kern, self._composite = _parse_optional(fh)
+
+    def get_bbox_char(self, c, isord=False):
+        if not isord:
+            c = ord(c)
+        return self._metrics[c].bbox
+
+    def string_width_height(self, s):
+        """
+        Return the string width (including kerning) and string height
+        as a (*w*, *h*) tuple.
+        """
+        if not len(s):
+            return 0, 0
+        total_width = 0
+        namelast = None
+        miny = 1e9
+        maxy = 0
+        for c in s:
+            if c == '\n':
+                continue
+            wx, name, bbox = self._metrics[ord(c)]
+
+            total_width += wx + self._kern.get((namelast, name), 0)
+            l, b, w, h = bbox
+            miny = min(miny, b)
+            maxy = max(maxy, b + h)
+
+            namelast = name
+
+        return total_width, maxy - miny
+
+    def get_str_bbox_and_descent(self, s):
+        """Return the string bounding box and the maximal descent."""
+        if not len(s):
+            return 0, 0, 0, 0, 0
+        total_width = 0
+        namelast = None
+        miny = 1e9
+        maxy = 0
+        left = 0
+        if not isinstance(s, str):
+            s = _to_str(s)
+        for c in s:
+            if c == '\n':
+                continue
+            name = uni2type1.get(ord(c), f"uni{ord(c):04X}")
+            try:
+                wx, _, bbox = self._metrics_by_name[name]
+            except KeyError:
+                name = 'question'
+                wx, _, bbox = self._metrics_by_name[name]
+            total_width += wx + self._kern.get((namelast, name), 0)
+            l, b, w, h = bbox
+            left = min(left, l)
+            miny = min(miny, b)
+            maxy = max(maxy, b + h)
+
+            namelast = name
+
+        return left, miny, total_width, maxy - miny, -miny
+
+    def get_str_bbox(self, s):
+        """Return the string bounding box."""
+        return self.get_str_bbox_and_descent(s)[:4]
+
+    def get_name_char(self, c, isord=False):
+        """Get the name of the character, i.e., ';' is 'semicolon'."""
+        if not isord:
+            c = ord(c)
+        return self._metrics[c].name
+
+    def get_width_char(self, c, isord=False):
+        """
+        Get the width of the character from the character metric WX field.
+        """
+        if not isord:
+            c = ord(c)
+        return self._metrics[c].width
+
+    def get_width_from_char_name(self, name):
+        """Get the width of the character from a type1 character name."""
+        return self._metrics_by_name[name].width
+
+    def get_height_char(self, c, isord=False):
+        """Get the bounding box (ink) height of character *c* (space is 0)."""
+        if not isord:
+            c = ord(c)
+        return self._metrics[c].bbox[-1]
+
+    def get_kern_dist(self, c1, c2):
+        """
+        Return the kerning pair distance (possibly 0) for chars *c1* and *c2*.
+        """
+        name1, name2 = self.get_name_char(c1), self.get_name_char(c2)
+        return self.get_kern_dist_from_name(name1, name2)
+
+    def get_kern_dist_from_name(self, name1, name2):
+        """
+        Return the kerning pair distance (possibly 0) for chars
+        *name1* and *name2*.
+        """
+        return self._kern.get((name1, name2), 0)
+
+    def get_fontname(self):
+        """Return the font name, e.g., 'Times-Roman'."""
+        return self._header[b'FontName']
+
+    @property
+    def postscript_name(self):  # For consistency with FT2Font.
+        return self.get_fontname()
+
+    def get_fullname(self):
+        """Return the font full name, e.g., 'Times-Roman'."""
+        name = self._header.get(b'FullName')
+        if name is None:  # use FontName as a substitute
+            name = self._header[b'FontName']
+        return name
+
+    def get_familyname(self):
+        """Return the font family name, e.g., 'Times'."""
+        name = self._header.get(b'FamilyName')
+        if name is not None:
+            return name
+
+        # FamilyName not specified so we'll make a guess
+        name = self.get_fullname()
+        extras = (r'(?i)([ -](regular|plain|italic|oblique|bold|semibold|'
+                  r'light|ultralight|extra|condensed))+$')
+        return re.sub(extras, '', name)
+
+    @property
+    def family_name(self):
+        """The font family name, e.g., 'Times'."""
+        return self.get_familyname()
+
+    def get_weight(self):
+        """Return the font weight, e.g., 'Bold' or 'Roman'."""
+        return self._header[b'Weight']
+
+    def get_angle(self):
+        """Return the fontangle as float."""
+        return self._header[b'ItalicAngle']
+
+    def get_capheight(self):
+        """Return the cap height as float."""
+        return self._header[b'CapHeight']
+
+    def get_xheight(self):
+        """Return the xheight as float."""
+        return self._header[b'XHeight']
+
+    def get_underline_thickness(self):
+        """Return the underline thickness as float."""
+        return self._header[b'UnderlineThickness']
+
+    def get_horizontal_stem_width(self):
+        """
+        Return the standard horizontal stem width as float, or *None* if
+        not specified in AFM file.
+        """
+        return self._header.get(b'StdHW', None)
+
+    def get_vertical_stem_width(self):
+        """
+        Return the standard vertical stem width as float, or *None* if
+        not specified in AFM file.
+        """
+        return self._header.get(b'StdVW', None)

infer_4_30_0/lib/python3.10/site-packages/matplotlib/_cm_bivar.py

@@ -0,0 +1,1312 @@
+# auto-generated by https://github.com/trygvrad/multivariate_colormaps
+# date: 2024-05-24
+
+import numpy as np
+from matplotlib.colors import SegmentedBivarColormap
+
+BiPeak = np.array(
+    [0.000, 0.674, 0.931, 0.000, 0.680, 0.922, 0.000, 0.685, 0.914, 0.000,
+     0.691, 0.906, 0.000, 0.696, 0.898, 0.000, 0.701, 0.890, 0.000, 0.706,
+     0.882, 0.000, 0.711, 0.875, 0.000, 0.715, 0.867, 0.000, 0.720, 0.860,
+     0.000, 0.725, 0.853, 0.000, 0.729, 0.845, 0.000, 0.733, 0.838, 0.000,
+     0.737, 0.831, 0.000, 0.741, 0.824, 0.000, 0.745, 0.816, 0.000, 0.749,
+     0.809, 0.000, 0.752, 0.802, 0.000, 0.756, 0.794, 0.000, 0.759, 0.787,
+     0.000, 0.762, 0.779, 0.000, 0.765, 0.771, 0.000, 0.767, 0.764, 0.000,
+     0.770, 0.755, 0.000, 0.772, 0.747, 0.000, 0.774, 0.739, 0.000, 0.776,
+     0.730, 0.000, 0.777, 0.721, 0.000, 0.779, 0.712, 0.021, 0.780, 0.702,
+     0.055, 0.781, 0.693, 0.079, 0.782, 0.682, 0.097, 0.782, 0.672, 0.111,
+     0.782, 0.661, 0.122, 0.782, 0.650, 0.132, 0.782, 0.639, 0.140, 0.781,
+     0.627, 0.147, 0.781, 0.615, 0.154, 0.780, 0.602, 0.159, 0.778, 0.589,
+     0.164, 0.777, 0.576, 0.169, 0.775, 0.563, 0.173, 0.773, 0.549, 0.177,
+     0.771, 0.535, 0.180, 0.768, 0.520, 0.184, 0.766, 0.505, 0.187, 0.763,
+     0.490, 0.190, 0.760, 0.474, 0.193, 0.756, 0.458, 0.196, 0.753, 0.442,
+     0.200, 0.749, 0.425, 0.203, 0.745, 0.408, 0.206, 0.741, 0.391, 0.210,
+     0.736, 0.373, 0.213, 0.732, 0.355, 0.216, 0.727, 0.337, 0.220, 0.722,
+     0.318, 0.224, 0.717, 0.298, 0.227, 0.712, 0.278, 0.231, 0.707, 0.258,
+     0.235, 0.701, 0.236, 0.239, 0.696, 0.214, 0.242, 0.690, 0.190, 0.246,
+     0.684, 0.165, 0.250, 0.678, 0.136, 0.000, 0.675, 0.934, 0.000, 0.681,
+     0.925, 0.000, 0.687, 0.917, 0.000, 0.692, 0.909, 0.000, 0.697, 0.901,
+     0.000, 0.703, 0.894, 0.000, 0.708, 0.886, 0.000, 0.713, 0.879, 0.000,
+     0.718, 0.872, 0.000, 0.722, 0.864, 0.000, 0.727, 0.857, 0.000, 0.731,
+     0.850, 0.000, 0.736, 0.843, 0.000, 0.740, 0.836, 0.000, 0.744, 0.829,
+     0.000, 0.748, 0.822, 0.000, 0.752, 0.815, 0.000, 0.755, 0.808, 0.000,
+     0.759, 0.800, 0.000, 0.762, 0.793, 0.000, 0.765, 0.786, 0.000, 0.768,
+     0.778, 0.000, 0.771, 0.770, 0.000, 0.773, 0.762, 0.051, 0.776, 0.754,
+     0.087, 0.778, 0.746, 0.111, 0.780, 0.737, 0.131, 0.782, 0.728, 0.146,
+     0.783, 0.719, 0.159, 0.784, 0.710, 0.171, 0.785, 0.700, 0.180, 0.786,
+     0.690, 0.189, 0.786, 0.680, 0.196, 0.787, 0.669, 0.202, 0.787, 0.658,
+     0.208, 0.786, 0.647, 0.213, 0.786, 0.635, 0.217, 0.785, 0.623, 0.221,
+     0.784, 0.610, 0.224, 0.782, 0.597, 0.227, 0.781, 0.584, 0.230, 0.779,
+     0.570, 0.232, 0.777, 0.556, 0.234, 0.775, 0.542, 0.236, 0.772, 0.527,
+     0.238, 0.769, 0.512, 0.240, 0.766, 0.497, 0.242, 0.763, 0.481, 0.244,
+     0.760, 0.465, 0.246, 0.756, 0.448, 0.248, 0.752, 0.432, 0.250, 0.748,
+     0.415, 0.252, 0.744, 0.397, 0.254, 0.739, 0.379, 0.256, 0.735, 0.361,
+     0.259, 0.730, 0.343, 0.261, 0.725, 0.324, 0.264, 0.720, 0.304, 0.266,
+     0.715, 0.284, 0.269, 0.709, 0.263, 0.271, 0.704, 0.242, 0.274, 0.698,
+     0.220, 0.277, 0.692, 0.196, 0.280, 0.686, 0.170, 0.283, 0.680, 0.143,
+     0.000, 0.676, 0.937, 0.000, 0.682, 0.928, 0.000, 0.688, 0.920, 0.000,
+     0.694, 0.913, 0.000, 0.699, 0.905, 0.000, 0.704, 0.897, 0.000, 0.710,
+     0.890, 0.000, 0.715, 0.883, 0.000, 0.720, 0.876, 0.000, 0.724, 0.869,
+     0.000, 0.729, 0.862, 0.000, 0.734, 0.855, 0.000, 0.738, 0.848, 0.000,
+     0.743, 0.841, 0.000, 0.747, 0.834, 0.000, 0.751, 0.827, 0.000, 0.755,
+     0.820, 0.000, 0.759, 0.813, 0.000, 0.762, 0.806, 0.003, 0.766, 0.799,
+     0.066, 0.769, 0.792, 0.104, 0.772, 0.784, 0.131, 0.775, 0.777, 0.152,
+     0.777, 0.769, 0.170, 0.780, 0.761, 0.185, 0.782, 0.753, 0.198, 0.784,
+     0.744, 0.209, 0.786, 0.736, 0.219, 0.787, 0.727, 0.228, 0.788, 0.717,
+     0.236, 0.789, 0.708, 0.243, 0.790, 0.698, 0.249, 0.791, 0.688, 0.254,
+     0.791, 0.677, 0.259, 0.791, 0.666, 0.263, 0.791, 0.654, 0.266, 0.790,
+     0.643, 0.269, 0.789, 0.631, 0.272, 0.788, 0.618, 0.274, 0.787, 0.605,
+     0.276, 0.785, 0.592, 0.278, 0.783, 0.578, 0.279, 0.781, 0.564, 0.280,
+     0.779, 0.549, 0.282, 0.776, 0.535, 0.283, 0.773, 0.519, 0.284, 0.770,
+     0.504, 0.285, 0.767, 0.488, 0.286, 0.763, 0.472, 0.287, 0.759, 0.455,
+     0.288, 0.756, 0.438, 0.289, 0.751, 0.421, 0.291, 0.747, 0.403, 0.292,
+     0.742, 0.385, 0.293, 0.738, 0.367, 0.295, 0.733, 0.348, 0.296, 0.728,
+     0.329, 0.298, 0.723, 0.310, 0.300, 0.717, 0.290, 0.302, 0.712, 0.269,
+     0.304, 0.706, 0.247, 0.306, 0.700, 0.225, 0.308, 0.694, 0.201, 0.310,
+     0.688, 0.176, 0.312, 0.682, 0.149, 0.000, 0.678, 0.939, 0.000, 0.683,
+     0.931, 0.000, 0.689, 0.923, 0.000, 0.695, 0.916, 0.000, 0.701, 0.908,
+     0.000, 0.706, 0.901, 0.000, 0.711, 0.894, 0.000, 0.717, 0.887, 0.000,
+     0.722, 0.880, 0.000, 0.727, 0.873, 0.000, 0.732, 0.866, 0.000, 0.736,
+     0.859, 0.000, 0.741, 0.853, 0.000, 0.745, 0.846, 0.000, 0.750, 0.839,
+     0.000, 0.754, 0.833, 0.035, 0.758, 0.826, 0.091, 0.762, 0.819, 0.126,
+     0.765, 0.812, 0.153, 0.769, 0.805, 0.174, 0.772, 0.798, 0.193, 0.775,
+     0.791, 0.209, 0.778, 0.783, 0.223, 0.781, 0.776, 0.236, 0.784, 0.768,
+     0.247, 0.786, 0.760, 0.257, 0.788, 0.752, 0.266, 0.790, 0.743, 0.273,
+     0.791, 0.734, 0.280, 0.793, 0.725, 0.287, 0.794, 0.715, 0.292, 0.794,
+     0.706, 0.297, 0.795, 0.695, 0.301, 0.795, 0.685, 0.305, 0.795, 0.674,
+     0.308, 0.795, 0.662, 0.310, 0.794, 0.651, 0.312, 0.794, 0.638, 0.314,
+     0.792, 0.626, 0.316, 0.791, 0.613, 0.317, 0.789, 0.599, 0.318, 0.787,
+     0.586, 0.319, 0.785, 0.571, 0.320, 0.783, 0.557, 0.320, 0.780, 0.542,
+     0.321, 0.777, 0.527, 0.321, 0.774, 0.511, 0.322, 0.770, 0.495, 0.322,
+     0.767, 0.478, 0.323, 0.763, 0.462, 0.323, 0.759, 0.445, 0.324, 0.755,
+     0.427, 0.325, 0.750, 0.410, 0.325, 0.745, 0.391, 0.326, 0.741, 0.373,
+     0.327, 0.736, 0.354, 0.328, 0.730, 0.335, 0.329, 0.725, 0.315, 0.330,
+     0.720, 0.295, 0.331, 0.714, 0.274, 0.333, 0.708, 0.253, 0.334, 0.702,
+     0.230, 0.336, 0.696, 0.207, 0.337, 0.690, 0.182, 0.339, 0.684, 0.154,
+     0.000, 0.679, 0.942, 0.000, 0.685, 0.934, 0.000, 0.691, 0.927, 0.000,
+     0.696, 0.919, 0.000, 0.702, 0.912, 0.000, 0.708, 0.905, 0.000, 0.713,
+     0.898, 0.000, 0.718, 0.891, 0.000, 0.724, 0.884, 0.000, 0.729, 0.877,
+     0.000, 0.734, 0.871, 0.000, 0.739, 0.864, 0.000, 0.743, 0.857, 0.035,
+     0.748, 0.851, 0.096, 0.752, 0.844, 0.133, 0.757, 0.838, 0.161, 0.761,
+     0.831, 0.185, 0.765, 0.825, 0.205, 0.769, 0.818, 0.223, 0.772, 0.811,
+     0.238, 0.776, 0.804, 0.252, 0.779, 0.797, 0.265, 0.782, 0.790, 0.276,
+     0.785, 0.783, 0.286, 0.788, 0.775, 0.296, 0.790, 0.767, 0.304, 0.792,
+     0.759, 0.311, 0.794, 0.751, 0.318, 0.796, 0.742, 0.324, 0.797, 0.733,
+     0.329, 0.798, 0.723, 0.334, 0.799, 0.714, 0.338, 0.799, 0.703, 0.341,
+     0.800, 0.693, 0.344, 0.800, 0.682, 0.347, 0.799, 0.670, 0.349, 0.799,
+     0.659, 0.351, 0.798, 0.646, 0.352, 0.797, 0.634, 0.353, 0.795, 0.621,
+     0.354, 0.794, 0.607, 0.354, 0.792, 0.593, 0.355, 0.789, 0.579, 0.355,
+     0.787, 0.564, 0.355, 0.784, 0.549, 0.355, 0.781, 0.534, 0.355, 0.778,
+     0.518, 0.355, 0.774, 0.502, 0.355, 0.770, 0.485, 0.355, 0.766, 0.468,
+     0.355, 0.762, 0.451, 0.355, 0.758, 0.434, 0.355, 0.753, 0.416, 0.356,
+     0.748, 0.397, 0.356, 0.743, 0.379, 0.356, 0.738, 0.360, 0.357, 0.733,
+     0.340, 0.357, 0.728, 0.321, 0.358, 0.722, 0.300, 0.359, 0.716, 0.279,
+     0.360, 0.710, 0.258, 0.361, 0.704, 0.235, 0.361, 0.698, 0.212, 0.362,
+     0.692, 0.187, 0.363, 0.686, 0.160, 0.000, 0.680, 0.945, 0.000, 0.686,
+     0.937, 0.000, 0.692, 0.930, 0.000, 0.698, 0.922, 0.000, 0.703, 0.915,
+     0.000, 0.709, 0.908, 0.000, 0.715, 0.901, 0.000, 0.720, 0.894, 0.000,
+     0.726, 0.888, 0.000, 0.731, 0.881, 0.007, 0.736, 0.875, 0.084, 0.741,
+     0.869, 0.127, 0.746, 0.862, 0.159, 0.751, 0.856, 0.185, 0.755, 0.850,
+     0.208, 0.760, 0.843, 0.227, 0.764, 0.837, 0.245, 0.768, 0.830, 0.260,
+     0.772, 0.824, 0.275, 0.776, 0.817, 0.288, 0.779, 0.811, 0.300, 0.783,
+     0.804, 0.310, 0.786, 0.797, 0.320, 0.789, 0.789, 0.329, 0.792, 0.782,
+     0.337, 0.794, 0.774, 0.345, 0.796, 0.766, 0.351, 0.798, 0.758, 0.357,
+     0.800, 0.749, 0.363, 0.801, 0.740, 0.367, 0.803, 0.731, 0.371, 0.803,
+     0.721, 0.375, 0.804, 0.711, 0.378, 0.804, 0.701, 0.380, 0.804, 0.690,
+     0.382, 0.804, 0.679, 0.384, 0.803, 0.667, 0.385, 0.802, 0.654, 0.386,
+     0.801, 0.642, 0.386, 0.800, 0.629, 0.387, 0.798, 0.615, 0.387, 0.796,
+     0.601, 0.387, 0.793, 0.587, 0.387, 0.791, 0.572, 0.387, 0.788, 0.557,
+     0.386, 0.785, 0.541, 0.386, 0.781, 0.525, 0.385, 0.778, 0.509, 0.385,
+     0.774, 0.492, 0.385, 0.770, 0.475, 0.384, 0.765, 0.457, 0.384, 0.761,
+     0.440, 0.384, 0.756, 0.422, 0.384, 0.751, 0.403, 0.384, 0.746, 0.384,
+     0.384, 0.741, 0.365, 0.384, 0.735, 0.346, 0.384, 0.730, 0.326, 0.384,
+     0.724, 0.305, 0.384, 0.718, 0.284, 0.385, 0.712, 0.263, 0.385, 0.706,
+     0.240, 0.386, 0.700, 0.217, 0.386, 0.694, 0.192, 0.387, 0.687, 0.165,
+     0.000, 0.680, 0.948, 0.000, 0.687, 0.940, 0.000, 0.693, 0.933, 0.000,
+     0.699, 0.925, 0.000, 0.705, 0.918, 0.000, 0.711, 0.912, 0.000, 0.716,
+     0.905, 0.000, 0.722, 0.898, 0.050, 0.728, 0.892, 0.109, 0.733, 0.886,
+     0.147, 0.738, 0.879, 0.177, 0.743, 0.873, 0.202, 0.748, 0.867, 0.224,
+     0.753, 0.861, 0.243, 0.758, 0.855, 0.261, 0.763, 0.849, 0.277, 0.767,
+     0.842, 0.292, 0.771, 0.836, 0.305, 0.775, 0.830, 0.318, 0.779, 0.823,
+     0.329, 0.783, 0.817, 0.340, 0.787, 0.810, 0.350, 0.790, 0.803, 0.359,
+     0.793, 0.796, 0.367, 0.796, 0.789, 0.374, 0.798, 0.782, 0.381, 0.801,
+     0.774, 0.387, 0.803, 0.766, 0.393, 0.804, 0.757, 0.397, 0.806, 0.748,
+     0.402, 0.807, 0.739, 0.405, 0.808, 0.729, 0.408, 0.809, 0.719, 0.411,
+     0.809, 0.709, 0.413, 0.809, 0.698, 0.415, 0.808, 0.687, 0.416, 0.808,
+     0.675, 0.417, 0.807, 0.663, 0.417, 0.806, 0.650, 0.417, 0.804, 0.637,
+     0.418, 0.802, 0.623, 0.417, 0.800, 0.609, 0.417, 0.798, 0.594, 0.416,
+     0.795, 0.579, 0.416, 0.792, 0.564, 0.415, 0.789, 0.548, 0.414, 0.785,
+     0.532, 0.414, 0.781, 0.515, 0.413, 0.777, 0.499, 0.412, 0.773, 0.481,
+     0.412, 0.769, 0.464, 0.411, 0.764, 0.446, 0.410, 0.759, 0.428, 0.410,
+     0.754, 0.409, 0.409, 0.749, 0.390, 0.409, 0.743, 0.371, 0.409, 0.738,
+     0.351, 0.409, 0.732, 0.331, 0.408, 0.726, 0.310, 0.408, 0.720, 0.289,
+     0.408, 0.714, 0.268, 0.408, 0.708, 0.245, 0.409, 0.702, 0.222, 0.409,
+     0.695, 0.197, 0.409, 0.689, 0.170, 0.000, 0.681, 0.950, 0.000, 0.688,
+     0.943, 0.000, 0.694, 0.936, 0.000, 0.700, 0.929, 0.000, 0.706, 0.922,
+     0.000, 0.712, 0.915, 0.074, 0.718, 0.908, 0.124, 0.724, 0.902, 0.159,
+     0.730, 0.896, 0.188, 0.735, 0.890, 0.213, 0.740, 0.884, 0.235, 0.746,
+     0.878, 0.255, 0.751, 0.872, 0.273, 0.756, 0.866, 0.289, 0.761, 0.860,
+     0.305, 0.766, 0.854, 0.319, 0.770, 0.848, 0.332, 0.775, 0.842, 0.344,
+     0.779, 0.836, 0.356, 0.783, 0.830, 0.366, 0.787, 0.823, 0.376, 0.790,
+     0.817, 0.385, 0.794, 0.810, 0.394, 0.797, 0.803, 0.401, 0.800, 0.796,
+     0.408, 0.802, 0.789, 0.414, 0.805, 0.781, 0.420, 0.807, 0.773, 0.425,
+     0.809, 0.765, 0.430, 0.810, 0.756, 0.433, 0.812, 0.747, 0.437, 0.813,
+     0.738, 0.440, 0.813, 0.728, 0.442, 0.814, 0.717, 0.444, 0.813, 0.706,
+     0.445, 0.813, 0.695, 0.446, 0.812, 0.683, 0.446, 0.811, 0.671, 0.447,
+     0.810, 0.658, 0.447, 0.809, 0.645, 0.446, 0.807, 0.631, 0.446, 0.804,
+     0.617, 0.445, 0.802, 0.602, 0.444, 0.799, 0.587, 0.443, 0.796, 0.571,
+     0.442, 0.792, 0.555, 0.441, 0.789, 0.539, 0.440, 0.785, 0.522, 0.439,
+     0.781, 0.505, 0.438, 0.776, 0.488, 0.437, 0.772, 0.470, 0.436, 0.767,
+     0.452, 0.435, 0.762, 0.433, 0.435, 0.757, 0.415, 0.434, 0.751, 0.396,
+     0.433, 0.746, 0.376, 0.432, 0.740, 0.356, 0.432, 0.734, 0.336, 0.431,
+     0.728, 0.315, 0.431, 0.722, 0.294, 0.431, 0.716, 0.272, 0.430, 0.710,
+     0.250, 0.430, 0.703, 0.226, 0.430, 0.697, 0.201, 0.430, 0.690, 0.175,
+     0.000, 0.682, 0.953, 0.000, 0.689, 0.946, 0.000, 0.695, 0.938, 0.002,
+     0.701, 0.932, 0.086, 0.708, 0.925, 0.133, 0.714, 0.918, 0.167, 0.720,
+     0.912, 0.196, 0.726, 0.906, 0.221, 0.731, 0.900, 0.243, 0.737, 0.894,
+     0.263, 0.743, 0.888, 0.281, 0.748, 0.882, 0.298, 0.753, 0.876, 0.314,
+     0.759, 0.870, 0.329, 0.764, 0.865, 0.342, 0.768, 0.859, 0.355, 0.773,
+     0.853, 0.368, 0.778, 0.847, 0.379, 0.782, 0.842, 0.390, 0.786, 0.836,
+     0.400, 0.790, 0.830, 0.409, 0.794, 0.823, 0.417, 0.798, 0.817, 0.425,
+     0.801, 0.810, 0.433, 0.804, 0.803, 0.439, 0.807, 0.796, 0.445, 0.809,
+     0.789, 0.451, 0.811, 0.781, 0.456, 0.813, 0.773, 0.460, 0.815, 0.764,
+     0.463, 0.816, 0.755, 0.466, 0.817, 0.746, 0.469, 0.818, 0.736, 0.471,
+     0.818, 0.725, 0.472, 0.818, 0.715, 0.473, 0.818, 0.703, 0.474, 0.817,
+     0.691, 0.474, 0.816, 0.679, 0.474, 0.815, 0.666, 0.474, 0.813, 0.653,
+     0.473, 0.811, 0.639, 0.473, 0.809, 0.624, 0.472, 0.806, 0.610, 0.471,
+     0.803, 0.594, 0.469, 0.800, 0.579, 0.468, 0.796, 0.562, 0.467, 0.792,
+     0.546, 0.466, 0.788, 0.529, 0.464, 0.784, 0.512, 0.463, 0.780, 0.494,
+     0.462, 0.775, 0.476, 0.460, 0.770, 0.458, 0.459, 0.765, 0.439, 0.458,
+     0.759, 0.420, 0.457, 0.754, 0.401, 0.456, 0.748, 0.381, 0.455, 0.742,
+     0.361, 0.454, 0.736, 0.341, 0.453, 0.730, 0.320, 0.453, 0.724, 0.299,
+     0.452, 0.718, 0.277, 0.452, 0.711, 0.254, 0.451, 0.705, 0.231, 0.451,
+     0.698, 0.206, 0.450, 0.691, 0.179, 0.000, 0.683, 0.955, 0.013, 0.689,
+     0.948, 0.092, 0.696, 0.941, 0.137, 0.702, 0.935, 0.171, 0.709, 0.928,
+     0.200, 0.715, 0.922, 0.225, 0.721, 0.916, 0.247, 0.727, 0.909, 0.267,
+     0.733, 0.904, 0.286, 0.739, 0.898, 0.303, 0.745, 0.892, 0.320, 0.750,
+     0.886, 0.335, 0.756, 0.881, 0.350, 0.761, 0.875, 0.363, 0.766, 0.870,
+     0.376, 0.771, 0.864, 0.388, 0.776, 0.859, 0.400, 0.781, 0.853, 0.411,
+     0.785, 0.847, 0.421, 0.790, 0.842, 0.430, 0.794, 0.836, 0.439, 0.798,
+     0.830, 0.448, 0.802, 0.824, 0.455, 0.805, 0.817, 0.462, 0.808, 0.810,
+     0.469, 0.811, 0.804, 0.475, 0.814, 0.796, 0.480, 0.816, 0.789, 0.484,
+     0.818, 0.781, 0.488, 0.820, 0.772, 0.492, 0.821, 0.763, 0.495, 0.822,
+     0.754, 0.497, 0.823, 0.744, 0.499, 0.823, 0.734, 0.500, 0.823, 0.723,
+     0.501, 0.823, 0.712, 0.501, 0.822, 0.700, 0.501, 0.821, 0.687, 0.501,
+     0.819, 0.674, 0.500, 0.818, 0.661, 0.499, 0.815, 0.647, 0.498, 0.813,
+     0.632, 0.497, 0.810, 0.617, 0.496, 0.807, 0.602, 0.494, 0.804, 0.586,
+     0.493, 0.800, 0.569, 0.491, 0.796, 0.553, 0.490, 0.792, 0.536, 0.488,
+     0.787, 0.518, 0.486, 0.783, 0.500, 0.485, 0.778, 0.482, 0.483, 0.773,
+     0.463, 0.482, 0.767, 0.445, 0.480, 0.762, 0.425, 0.479, 0.756, 0.406,
+     0.478, 0.750, 0.386, 0.477, 0.744, 0.366, 0.476, 0.738, 0.345, 0.475,
+     0.732, 0.325, 0.474, 0.726, 0.303, 0.473, 0.719, 0.281, 0.472, 0.713,
+     0.258, 0.471, 0.706, 0.235, 0.470, 0.699, 0.210, 0.469, 0.692, 0.184,
+     0.095, 0.683, 0.958, 0.139, 0.690, 0.951, 0.173, 0.697, 0.944, 0.201,
+     0.703, 0.938, 0.226, 0.710, 0.931, 0.249, 0.716, 0.925, 0.269, 0.723,
+     0.919, 0.288, 0.729, 0.913, 0.306, 0.735, 0.907, 0.323, 0.741, 0.902,
+     0.339, 0.747, 0.896, 0.354, 0.752, 0.891, 0.368, 0.758, 0.885, 0.382,
+     0.764, 0.880, 0.394, 0.769, 0.875, 0.407, 0.774, 0.869, 0.418, 0.779,
+     0.864, 0.429, 0.784, 0.859, 0.440, 0.789, 0.853, 0.450, 0.793, 0.848,
+     0.459, 0.798, 0.842, 0.468, 0.802, 0.836, 0.476, 0.806, 0.830, 0.483,
+     0.809, 0.824, 0.490, 0.812, 0.818, 0.496, 0.815, 0.811, 0.502, 0.818,
+     0.804, 0.507, 0.821, 0.796, 0.512, 0.823, 0.789, 0.515, 0.825, 0.780,
+     0.519, 0.826, 0.772, 0.521, 0.827, 0.762, 0.524, 0.828, 0.753, 0.525,
+     0.828, 0.742, 0.526, 0.828, 0.732, 0.527, 0.828, 0.720, 0.527, 0.827,
+     0.708, 0.527, 0.826, 0.696, 0.526, 0.824, 0.683, 0.525, 0.822, 0.669,
+     0.524, 0.820, 0.655, 0.523, 0.817, 0.640, 0.522, 0.814, 0.625, 0.520,
+     0.811, 0.609, 0.518, 0.808, 0.593, 0.516, 0.804, 0.576, 0.515, 0.800,
+     0.559, 0.513, 0.795, 0.542, 0.511, 0.791, 0.524, 0.509, 0.786, 0.506,
+     0.507, 0.781, 0.488, 0.505, 0.775, 0.469, 0.504, 0.770, 0.450, 0.502,
+     0.764, 0.431, 0.500, 0.759, 0.411, 0.499, 0.753, 0.391, 0.497, 0.746,
+     0.371, 0.496, 0.740, 0.350, 0.495, 0.734, 0.329, 0.494, 0.727, 0.307,
+     0.492, 0.721, 0.285, 0.491, 0.714, 0.262, 0.490, 0.707, 0.239, 0.489,
+     0.700, 0.214, 0.488, 0.693, 0.188, 0.172, 0.684, 0.961, 0.201, 0.691,
+     0.954, 0.226, 0.698, 0.947, 0.248, 0.704, 0.941, 0.269, 0.711, 0.934,
+     0.289, 0.717, 0.928, 0.307, 0.724, 0.922, 0.324, 0.730, 0.917, 0.340,
+     0.736, 0.911, 0.356, 0.743, 0.906, 0.370, 0.749, 0.900, 0.384, 0.755,
+     0.895, 0.398, 0.760, 0.890, 0.411, 0.766, 0.885, 0.423, 0.772, 0.880,
+     0.435, 0.777, 0.874, 0.446, 0.782, 0.869, 0.457, 0.787, 0.864, 0.467,
+     0.792, 0.859, 0.477, 0.797, 0.854, 0.486, 0.801, 0.848, 0.494, 0.806,
+     0.843, 0.502, 0.810, 0.837, 0.510, 0.813, 0.831, 0.517, 0.817, 0.825,
+     0.523, 0.820, 0.818, 0.528, 0.823, 0.811, 0.533, 0.825, 0.804, 0.538,
+     0.828, 0.797, 0.542, 0.829, 0.788, 0.545, 0.831, 0.780, 0.547, 0.832,
+     0.771, 0.549, 0.833, 0.761, 0.551, 0.833, 0.751, 0.552, 0.833, 0.740,
+     0.552, 0.833, 0.729, 0.552, 0.832, 0.717, 0.551, 0.830, 0.704, 0.551,
+     0.829, 0.691, 0.550, 0.827, 0.677, 0.548, 0.824, 0.663, 0.547, 0.822,
+     0.648, 0.545, 0.819, 0.632, 0.543, 0.815, 0.617, 0.541, 0.812, 0.600,
+     0.539, 0.808, 0.583, 0.537, 0.803, 0.566, 0.535, 0.799, 0.549, 0.533,
+     0.794, 0.531, 0.531, 0.789, 0.512, 0.529, 0.784, 0.494, 0.527, 0.778,
+     0.475, 0.525, 0.773, 0.455, 0.523, 0.767, 0.436, 0.521, 0.761, 0.416,
+     0.519, 0.755, 0.396, 0.517, 0.748, 0.375, 0.516, 0.742, 0.354, 0.514,
+     0.735, 0.333, 0.513, 0.729, 0.311, 0.511, 0.722, 0.289, 0.510, 0.715,
+     0.266, 0.509, 0.708, 0.242, 0.507, 0.701, 0.218, 0.506, 0.694, 0.191,
+     0.224, 0.684, 0.963, 0.247, 0.691, 0.956, 0.268, 0.698, 0.950, 0.287,
+     0.705, 0.943, 0.305, 0.712, 0.937, 0.323, 0.719, 0.931, 0.339, 0.725,
+     0.926, 0.355, 0.732, 0.920, 0.370, 0.738, 0.915, 0.385, 0.744, 0.909,
+     0.399, 0.751, 0.904, 0.412, 0.757, 0.899, 0.425, 0.763, 0.894, 0.438,
+     0.768, 0.889, 0.450, 0.774, 0.884, 0.461, 0.780, 0.879, 0.472, 0.785,
+     0.875, 0.483, 0.790, 0.870, 0.493, 0.795, 0.865, 0.502, 0.800, 0.860,
+     0.511, 0.805, 0.855, 0.520, 0.809, 0.849, 0.528, 0.814, 0.844, 0.535,
+     0.818, 0.838, 0.542, 0.821, 0.832, 0.548, 0.824, 0.826, 0.554, 0.827,
+     0.819, 0.559, 0.830, 0.812, 0.563, 0.832, 0.805, 0.567, 0.834, 0.797,
+     0.570, 0.836, 0.788, 0.572, 0.837, 0.779, 0.574, 0.838, 0.770, 0.575,
+     0.838, 0.760, 0.576, 0.838, 0.749, 0.576, 0.838, 0.737, 0.576, 0.837,
+     0.725, 0.575, 0.835, 0.713, 0.574, 0.834, 0.699, 0.573, 0.831, 0.685,
+     0.571, 0.829, 0.671, 0.570, 0.826, 0.656, 0.568, 0.823, 0.640, 0.566,
+     0.819, 0.624, 0.563, 0.815, 0.607, 0.561, 0.811, 0.590, 0.559, 0.807,
+     0.573, 0.556, 0.802, 0.555, 0.554, 0.797, 0.537, 0.552, 0.792, 0.518,
+     0.549, 0.786, 0.499, 0.547, 0.781, 0.480, 0.545, 0.775, 0.460, 0.543,
+     0.769, 0.441, 0.541, 0.763, 0.420, 0.539, 0.756, 0.400, 0.537, 0.750,
+     0.379, 0.535, 0.743, 0.358, 0.533, 0.737, 0.337, 0.531, 0.730, 0.315,
+     0.530, 0.723, 0.293, 0.528, 0.716, 0.270, 0.527, 0.709, 0.246, 0.525,
+     0.702, 0.221, 0.524, 0.694, 0.195, 0.265, 0.685, 0.965, 0.284, 0.692,
+     0.959, 0.303, 0.699, 0.952, 0.320, 0.706, 0.946, 0.337, 0.713, 0.940,
+     0.353, 0.720, 0.935, 0.369, 0.726, 0.929, 0.384, 0.733, 0.924, 0.398,
+     0.739, 0.918, 0.412, 0.746, 0.913, 0.425, 0.752, 0.908, 0.438, 0.759,
+     0.903, 0.451, 0.765, 0.899, 0.463, 0.771, 0.894, 0.475, 0.777, 0.889,
+     0.486, 0.782, 0.884, 0.497, 0.788, 0.880, 0.507, 0.793, 0.875, 0.517,
+     0.799, 0.870, 0.527, 0.804, 0.866, 0.536, 0.809, 0.861, 0.544, 0.813,
+     0.856, 0.552, 0.818, 0.850, 0.560, 0.822, 0.845, 0.566, 0.826, 0.839,
+     0.573, 0.829, 0.833, 0.578, 0.832, 0.827, 0.583, 0.835, 0.820, 0.587,
+     0.837, 0.813, 0.591, 0.839, 0.805, 0.594, 0.841, 0.797, 0.596, 0.842,
+     0.788, 0.598, 0.843, 0.778, 0.599, 0.843, 0.768, 0.600, 0.843, 0.758,
+     0.600, 0.843, 0.746, 0.599, 0.842, 0.734, 0.599, 0.840, 0.721, 0.597,
+     0.838, 0.708, 0.596, 0.836, 0.694, 0.594, 0.834, 0.679, 0.592, 0.831,
+     0.663, 0.590, 0.827, 0.648, 0.587, 0.823, 0.631, 0.585, 0.819, 0.614,
+     0.582, 0.815, 0.597, 0.580, 0.810, 0.579, 0.577, 0.805, 0.561, 0.575,
+     0.800, 0.542, 0.572, 0.795, 0.524, 0.569, 0.789, 0.504, 0.567, 0.783,
+     0.485, 0.565, 0.777, 0.465, 0.562, 0.771, 0.445, 0.560, 0.765, 0.425,
+     0.558, 0.758, 0.404, 0.556, 0.752, 0.383, 0.554, 0.745, 0.362, 0.552,
+     0.738, 0.341, 0.550, 0.731, 0.319, 0.548, 0.724, 0.296, 0.546, 0.717,
+     0.273, 0.544, 0.709, 0.249, 0.542, 0.702, 0.224, 0.541, 0.695, 0.198,
+     0.299, 0.685, 0.968, 0.317, 0.692, 0.961, 0.334, 0.699, 0.955, 0.350,
+     0.706, 0.949, 0.366, 0.713, 0.943, 0.381, 0.720, 0.938, 0.395, 0.727,
+     0.932, 0.410, 0.734, 0.927, 0.423, 0.741, 0.922, 0.437, 0.747, 0.917,
+     0.450, 0.754, 0.912, 0.463, 0.760, 0.907, 0.475, 0.767, 0.903, 0.487,
+     0.773, 0.898, 0.498, 0.779, 0.894, 0.509, 0.785, 0.889, 0.520, 0.791,
+     0.885, 0.531, 0.796, 0.880, 0.540, 0.802, 0.876, 0.550, 0.807, 0.871,
+     0.559, 0.812, 0.867, 0.568, 0.817, 0.862, 0.576, 0.822, 0.857, 0.583,
+     0.826, 0.852, 0.590, 0.830, 0.847, 0.596, 0.834, 0.841, 0.602, 0.837,
+     0.835, 0.607, 0.840, 0.828, 0.611, 0.843, 0.821, 0.615, 0.845, 0.814,
+     0.618, 0.846, 0.805, 0.620, 0.848, 0.797, 0.622, 0.848, 0.787, 0.623,
+     0.849, 0.777, 0.623, 0.849, 0.766, 0.623, 0.848, 0.755, 0.622, 0.847,
+     0.743, 0.621, 0.845, 0.730, 0.620, 0.843, 0.716, 0.618, 0.841, 0.702,
+     0.616, 0.838, 0.687, 0.613, 0.835, 0.671, 0.611, 0.831, 0.655, 0.608,
+     0.827, 0.638, 0.606, 0.823, 0.621, 0.603, 0.818, 0.604, 0.600, 0.814,
+     0.585, 0.597, 0.808, 0.567, 0.594, 0.803, 0.548, 0.592, 0.797, 0.529,
+     0.589, 0.792, 0.510, 0.586, 0.785, 0.490, 0.584, 0.779, 0.470, 0.581,
+     0.773, 0.450, 0.579, 0.766, 0.429, 0.576, 0.760, 0.408, 0.574, 0.753,
+     0.387, 0.572, 0.746, 0.366, 0.569, 0.739, 0.344, 0.567, 0.732, 0.322,
+     0.565, 0.725, 0.299, 0.563, 0.717, 0.276, 0.561, 0.710, 0.252, 0.559,
+     0.703, 0.227, 0.557, 0.695, 0.201, 0.329, 0.685, 0.970, 0.346, 0.692,
+     0.964, 0.362, 0.699, 0.958, 0.377, 0.707, 0.952, 0.392, 0.714, 0.946,
+     0.406, 0.721, 0.941, 0.420, 0.728, 0.935, 0.434, 0.735, 0.930, 0.447,
+     0.742, 0.925, 0.460, 0.749, 0.920, 0.473, 0.756, 0.916, 0.485, 0.762,
+     0.911, 0.497, 0.769, 0.907, 0.509, 0.775, 0.903, 0.521, 0.781, 0.898,
+     0.532, 0.788, 0.894, 0.542, 0.794, 0.890, 0.553, 0.799, 0.886, 0.563,
+     0.805, 0.882, 0.572, 0.811, 0.877, 0.581, 0.816, 0.873, 0.590, 0.821,
+     0.868, 0.598, 0.826, 0.864, 0.606, 0.830, 0.859, 0.613, 0.834, 0.854,
+     0.619, 0.838, 0.848, 0.625, 0.842, 0.842, 0.630, 0.845, 0.836, 0.634,
+     0.848, 0.829, 0.638, 0.850, 0.822, 0.641, 0.852, 0.814, 0.643, 0.853,
+     0.805, 0.645, 0.854, 0.796, 0.645, 0.854, 0.786, 0.646, 0.854, 0.775,
+     0.645, 0.853, 0.764, 0.645, 0.852, 0.751, 0.643, 0.851, 0.738, 0.642,
+     0.848, 0.725, 0.639, 0.846, 0.710, 0.637, 0.843, 0.695, 0.635, 0.839,
+     0.679, 0.632, 0.836, 0.662, 0.629, 0.831, 0.645, 0.626, 0.827, 0.628,
+     0.623, 0.822, 0.610, 0.620, 0.817, 0.592, 0.617, 0.811, 0.573, 0.614,
+     0.806, 0.554, 0.611, 0.800, 0.534, 0.608, 0.794, 0.515, 0.605, 0.788,
+     0.495, 0.602, 0.781, 0.474, 0.599, 0.775, 0.454, 0.597, 0.768, 0.433,
+     0.594, 0.761, 0.412, 0.592, 0.754, 0.391, 0.589, 0.747, 0.369, 0.587,
+     0.740, 0.347, 0.584, 0.733, 0.325, 0.582, 0.725, 0.302, 0.580, 0.718,
+     0.279, 0.577, 0.710, 0.255, 0.575, 0.703, 0.230, 0.573, 0.695, 0.204,
+     0.357, 0.685, 0.972, 0.372, 0.692, 0.966, 0.387, 0.700, 0.960, 0.401,
+     0.707, 0.954, 0.416, 0.714, 0.949, 0.429, 0.722, 0.943, 0.443, 0.729,
+     0.938, 0.456, 0.736, 0.933, 0.469, 0.743, 0.929, 0.482, 0.750, 0.924,
+     0.494, 0.757, 0.919, 0.507, 0.764, 0.915, 0.519, 0.771, 0.911, 0.530,
+     0.777, 0.907, 0.542, 0.784, 0.903, 0.553, 0.790, 0.899, 0.563, 0.796,
+     0.895, 0.574, 0.802, 0.891, 0.584, 0.808, 0.887, 0.593, 0.814, 0.883,
+     0.603, 0.820, 0.879, 0.611, 0.825, 0.875, 0.620, 0.830, 0.870, 0.627,
+     0.835, 0.866, 0.635, 0.839, 0.861, 0.641, 0.843, 0.856, 0.647, 0.847,
+     0.850, 0.652, 0.850, 0.844, 0.657, 0.853, 0.838, 0.660, 0.855, 0.831,
+     0.663, 0.857, 0.823, 0.666, 0.859, 0.814, 0.667, 0.859, 0.805, 0.668,
+     0.860, 0.795, 0.668, 0.860, 0.784, 0.667, 0.859, 0.773, 0.666, 0.858,
+     0.760, 0.665, 0.856, 0.747, 0.663, 0.853, 0.733, 0.661, 0.851, 0.718,
+     0.658, 0.847, 0.703, 0.655, 0.844, 0.687, 0.652, 0.840, 0.670, 0.649,
+     0.835, 0.652, 0.646, 0.830, 0.635, 0.642, 0.825, 0.616, 0.639, 0.820,
+     0.598, 0.636, 0.814, 0.579, 0.633, 0.808, 0.559, 0.629, 0.802, 0.539,
+     0.626, 0.796, 0.519, 0.623, 0.790, 0.499, 0.620, 0.783, 0.479, 0.617,
+     0.776, 0.458, 0.614, 0.769, 0.437, 0.611, 0.762, 0.416, 0.609, 0.755,
+     0.394, 0.606, 0.748, 0.372, 0.603, 0.740, 0.350, 0.601, 0.733, 0.328,
+     0.598, 0.726, 0.305, 0.596, 0.718, 0.282, 0.593, 0.710, 0.257, 0.591,
+     0.703, 0.232, 0.589, 0.695, 0.206, 0.381, 0.684, 0.974, 0.396, 0.692,
+     0.968, 0.410, 0.700, 0.962, 0.424, 0.707, 0.957, 0.438, 0.715, 0.951,
+     0.451, 0.722, 0.946, 0.464, 0.729, 0.941, 0.477, 0.737, 0.936, 0.490,
+     0.744, 0.932, 0.503, 0.751, 0.927, 0.515, 0.758, 0.923, 0.527, 0.765,
+     0.919, 0.539, 0.772, 0.915, 0.550, 0.779, 0.911, 0.562, 0.786, 0.907,
+     0.573, 0.792, 0.903, 0.584, 0.799, 0.900, 0.594, 0.805, 0.896, 0.604,
+     0.811, 0.892, 0.614, 0.817, 0.889, 0.623, 0.823, 0.885, 0.632, 0.829,
+     0.881, 0.641, 0.834, 0.877, 0.649, 0.839, 0.873, 0.656, 0.844, 0.868,
+     0.663, 0.848, 0.863, 0.669, 0.852, 0.858, 0.674, 0.855, 0.852, 0.679,
+     0.858, 0.846, 0.682, 0.861, 0.839, 0.685, 0.863, 0.832, 0.688, 0.864,
+     0.823, 0.689, 0.865, 0.814, 0.690, 0.865, 0.804, 0.690, 0.865, 0.794,
+     0.689, 0.864, 0.782, 0.688, 0.863, 0.769, 0.686, 0.861, 0.756, 0.684,
+     0.858, 0.742, 0.681, 0.855, 0.726, 0.678, 0.852, 0.711, 0.675, 0.848,
+     0.694, 0.672, 0.844, 0.677, 0.668, 0.839, 0.659, 0.665, 0.834, 0.641,
+     0.662, 0.829, 0.622, 0.658, 0.823, 0.603, 0.655, 0.817, 0.584, 0.651,
+     0.811, 0.564, 0.648, 0.805, 0.544, 0.644, 0.798, 0.524, 0.641, 0.791,
+     0.503, 0.638, 0.785, 0.483, 0.635, 0.778, 0.462, 0.631, 0.770, 0.440,
+     0.628, 0.763, 0.419, 0.625, 0.756, 0.397, 0.623, 0.748, 0.375, 0.620,
+     0.741, 0.353, 0.617, 0.733, 0.330, 0.614, 0.726, 0.307, 0.612, 0.718,
+     0.284, 0.609, 0.710, 0.260, 0.606, 0.702, 0.235, 0.604, 0.694, 0.208,
+     0.404, 0.684, 0.977, 0.418, 0.692, 0.971, 0.432, 0.699, 0.965, 0.445,
+     0.707, 0.959, 0.458, 0.715, 0.954, 0.472, 0.722, 0.949, 0.484, 0.730,
+     0.944, 0.497, 0.737, 0.939, 0.510, 0.745, 0.935, 0.522, 0.752, 0.931,
+     0.534, 0.759, 0.926, 0.546, 0.767, 0.922, 0.558, 0.774, 0.919, 0.569,
+     0.781, 0.915, 0.581, 0.788, 0.911, 0.592, 0.794, 0.908, 0.603, 0.801,
+     0.904, 0.613, 0.808, 0.901, 0.624, 0.814, 0.897, 0.633, 0.820, 0.894,
+     0.643, 0.826, 0.891, 0.652, 0.832, 0.887, 0.661, 0.838, 0.883, 0.669,
+     0.843, 0.879, 0.677, 0.848, 0.875, 0.684, 0.853, 0.871, 0.690, 0.857,
+     0.866, 0.695, 0.860, 0.860, 0.700, 0.864, 0.855, 0.704, 0.866, 0.848,
+     0.707, 0.869, 0.841, 0.709, 0.870, 0.833, 0.711, 0.871, 0.824, 0.711,
+     0.871, 0.814, 0.711, 0.871, 0.803, 0.710, 0.870, 0.791, 0.709, 0.868,
+     0.778, 0.707, 0.866, 0.765, 0.704, 0.864, 0.750, 0.701, 0.860, 0.735,
+     0.698, 0.857, 0.718, 0.695, 0.852, 0.702, 0.691, 0.848, 0.684, 0.688,
+     0.843, 0.666, 0.684, 0.837, 0.647, 0.680, 0.832, 0.628, 0.676, 0.826,
+     0.609, 0.673, 0.820, 0.589, 0.669, 0.813, 0.569, 0.665, 0.807, 0.549,
+     0.662, 0.800, 0.528, 0.658, 0.793, 0.507, 0.655, 0.786, 0.486, 0.651,
+     0.779, 0.465, 0.648, 0.771, 0.444, 0.645, 0.764, 0.422, 0.642, 0.756,
+     0.400, 0.639, 0.749, 0.378, 0.636, 0.741, 0.356, 0.633, 0.733, 0.333,
+     0.630, 0.726, 0.310, 0.627, 0.718, 0.286, 0.624, 0.710, 0.262, 0.621,
+     0.702, 0.237, 0.619, 0.694, 0.210, 0.425, 0.683, 0.979, 0.439, 0.691,
+     0.973, 0.452, 0.699, 0.967, 0.465, 0.707, 0.962, 0.478, 0.715, 0.956,
+     0.491, 0.722, 0.951, 0.503, 0.730, 0.947, 0.516, 0.738, 0.942, 0.528,
+     0.745, 0.938, 0.540, 0.753, 0.934, 0.552, 0.760, 0.930, 0.564, 0.768,
+     0.926, 0.576, 0.775, 0.922, 0.588, 0.782, 0.919, 0.599, 0.789, 0.915,
+     0.610, 0.797, 0.912, 0.621, 0.803, 0.909, 0.632, 0.810, 0.906, 0.642,
+     0.817, 0.902, 0.652, 0.823, 0.899, 0.662, 0.830, 0.896, 0.671, 0.836,
+     0.893, 0.680, 0.842, 0.890, 0.689, 0.847, 0.886, 0.697, 0.853, 0.882,
+     0.704, 0.857, 0.878, 0.710, 0.862, 0.874, 0.716, 0.866, 0.869, 0.721,
+     0.869, 0.863, 0.725, 0.872, 0.857, 0.729, 0.874, 0.850, 0.731, 0.876,
+     0.842, 0.732, 0.877, 0.833, 0.733, 0.877, 0.823, 0.732, 0.877, 0.812,
+     0.731, 0.876, 0.800, 0.729, 0.874, 0.787, 0.727, 0.872, 0.773, 0.724,
+     0.869, 0.759, 0.721, 0.865, 0.743, 0.718, 0.861, 0.726, 0.714, 0.857,
+     0.709, 0.710, 0.852, 0.691, 0.706, 0.846, 0.672, 0.702, 0.841, 0.653,
+     0.698, 0.835, 0.634, 0.694, 0.828, 0.614, 0.690, 0.822, 0.594, 0.686,
+     0.815, 0.574, 0.683, 0.808, 0.553, 0.679, 0.801, 0.532, 0.675, 0.794,
+     0.511, 0.672, 0.787, 0.490, 0.668, 0.779, 0.468, 0.665, 0.772, 0.446,
+     0.661, 0.764, 0.425, 0.658, 0.757, 0.403, 0.654, 0.749, 0.380, 0.651,
+     0.741, 0.358, 0.648, 0.733, 0.335, 0.645, 0.725, 0.312, 0.642, 0.717,
+     0.288, 0.639, 0.709, 0.264, 0.636, 0.701, 0.238, 0.633, 0.693, 0.212,
+     0.445, 0.682, 0.981, 0.458, 0.691, 0.975, 0.471, 0.699, 0.969, 0.484,
+     0.707, 0.964, 0.496, 0.715, 0.959, 0.509, 0.722, 0.954, 0.521, 0.730,
+     0.949, 0.534, 0.738, 0.945, 0.546, 0.746, 0.941, 0.558, 0.753, 0.937,
+     0.570, 0.761, 0.933, 0.582, 0.769, 0.929, 0.593, 0.776, 0.926, 0.605,
+     0.784, 0.922, 0.616, 0.791, 0.919, 0.628, 0.798, 0.916, 0.639, 0.806,
+     0.913, 0.649, 0.813, 0.910, 0.660, 0.820, 0.907, 0.670, 0.826, 0.904,
+     0.680, 0.833, 0.902, 0.690, 0.839, 0.899, 0.699, 0.846, 0.896, 0.708,
+     0.851, 0.893, 0.716, 0.857, 0.889, 0.724, 0.862, 0.885, 0.731, 0.867,
+     0.881, 0.737, 0.871, 0.877, 0.742, 0.875, 0.872, 0.746, 0.878, 0.866,
+     0.750, 0.880, 0.859, 0.752, 0.882, 0.851, 0.753, 0.883, 0.843, 0.754,
+     0.883, 0.833, 0.753, 0.883, 0.822, 0.752, 0.882, 0.810, 0.750, 0.880,
+     0.797, 0.747, 0.877, 0.782, 0.744, 0.874, 0.767, 0.740, 0.870, 0.751,
+     0.737, 0.866, 0.734, 0.733, 0.861, 0.716, 0.729, 0.855, 0.697, 0.724,
+     0.850, 0.678, 0.720, 0.844, 0.659, 0.716, 0.837, 0.639, 0.712, 0.831,
+     0.619, 0.708, 0.824, 0.598, 0.704, 0.817, 0.578, 0.699, 0.810, 0.557,
+     0.696, 0.803, 0.535, 0.692, 0.795, 0.514, 0.688, 0.788, 0.493, 0.684,
+     0.780, 0.471, 0.680, 0.772, 0.449, 0.677, 0.765, 0.427, 0.673, 0.757,
+     0.405, 0.670, 0.749, 0.382, 0.666, 0.741, 0.360, 0.663, 0.733, 0.337,
+     0.660, 0.725, 0.313, 0.657, 0.716, 0.289, 0.653, 0.708, 0.265, 0.650,
+     0.700, 0.240, 0.647, 0.692, 0.213, 0.464, 0.681, 0.982, 0.476, 0.690,
+     0.977, 0.489, 0.698, 0.971, 0.501, 0.706, 0.966, 0.514, 0.714, 0.961,
+     0.526, 0.722, 0.956, 0.538, 0.730, 0.952, 0.550, 0.738, 0.947, 0.562,
+     0.746, 0.943, 0.574, 0.754, 0.939, 0.586, 0.762, 0.936, 0.598, 0.769,
+     0.932, 0.610, 0.777, 0.929, 0.621, 0.785, 0.926, 0.633, 0.792, 0.923,
+     0.644, 0.800, 0.920, 0.655, 0.807, 0.917, 0.666, 0.815, 0.915, 0.677,
+     0.822, 0.912, 0.688, 0.829, 0.909, 0.698, 0.836, 0.907, 0.708, 0.843,
+     0.904, 0.717, 0.849, 0.902, 0.727, 0.855, 0.899, 0.735, 0.861, 0.896,
+     0.743, 0.867, 0.893, 0.750, 0.872, 0.889, 0.757, 0.877, 0.885, 0.762,
+     0.881, 0.880, 0.767, 0.884, 0.875, 0.770, 0.887, 0.868, 0.773, 0.888,
+     0.861, 0.774, 0.889, 0.852, 0.774, 0.890, 0.842, 0.774, 0.889, 0.831,
+     0.772, 0.888, 0.819, 0.770, 0.885, 0.806, 0.767, 0.883, 0.791, 0.763,
+     0.879, 0.775, 0.759, 0.875, 0.759, 0.755, 0.870, 0.741, 0.751, 0.865,
+     0.723, 0.747, 0.859, 0.704, 0.742, 0.853, 0.684, 0.738, 0.847, 0.664,
+     0.733, 0.840, 0.644, 0.729, 0.833, 0.623, 0.724, 0.826, 0.603, 0.720,
+     0.819, 0.581, 0.716, 0.811, 0.560, 0.712, 0.804, 0.539, 0.708, 0.796,
+     0.517, 0.704, 0.788, 0.495, 0.700, 0.780, 0.473, 0.696, 0.772, 0.451,
+     0.692, 0.764, 0.429, 0.688, 0.756, 0.407, 0.685, 0.748, 0.384, 0.681,
+     0.740, 0.361, 0.678, 0.732, 0.338, 0.674, 0.724, 0.315, 0.671, 0.715,
+     0.291, 0.667, 0.707, 0.266, 0.664, 0.699, 0.241, 0.661, 0.691, 0.214,
+     0.481, 0.680, 0.984, 0.494, 0.689, 0.978, 0.506, 0.697, 0.973, 0.518,
+     0.705, 0.968, 0.530, 0.713, 0.963, 0.542, 0.722, 0.958, 0.554, 0.730,
+     0.954, 0.566, 0.738, 0.950, 0.578, 0.746, 0.946, 0.590, 0.754, 0.942,
+     0.602, 0.762, 0.939, 0.614, 0.770, 0.935, 0.626, 0.778, 0.932, 0.637,
+     0.786, 0.929, 0.649, 0.794, 0.926, 0.660, 0.801, 0.924, 0.671, 0.809,
+     0.921, 0.683, 0.817, 0.919, 0.694, 0.824, 0.916, 0.704, 0.832, 0.914,
+     0.715, 0.839, 0.912, 0.725, 0.846, 0.910, 0.735, 0.853, 0.908, 0.744,
+     0.859, 0.905, 0.753, 0.866, 0.903, 0.762, 0.872, 0.900, 0.770, 0.877,
+     0.897, 0.776, 0.882, 0.893, 0.782, 0.886, 0.889, 0.787, 0.890, 0.884,
+     0.791, 0.893, 0.878, 0.794, 0.895, 0.871, 0.795, 0.896, 0.862, 0.795,
+     0.896, 0.852, 0.794, 0.895, 0.841, 0.792, 0.894, 0.829, 0.789, 0.891,
+     0.815, 0.786, 0.888, 0.800, 0.782, 0.884, 0.783, 0.778, 0.879, 0.766,
+     0.774, 0.874, 0.748, 0.769, 0.868, 0.729, 0.764, 0.862, 0.710, 0.760,
+     0.856, 0.690, 0.755, 0.849, 0.669, 0.750, 0.842, 0.649, 0.745, 0.835,
+     0.628, 0.741, 0.827, 0.606, 0.736, 0.820, 0.585, 0.732, 0.812, 0.563,
+     0.728, 0.804, 0.542, 0.723, 0.796, 0.520, 0.719, 0.788, 0.498, 0.715,
+     0.780, 0.475, 0.711, 0.772, 0.453, 0.707, 0.764, 0.431, 0.703, 0.756,
+     0.408, 0.699, 0.748, 0.386, 0.696, 0.739, 0.363, 0.692, 0.731, 0.339,
+     0.688, 0.723, 0.316, 0.685, 0.714, 0.292, 0.681, 0.706, 0.267, 0.678,
+     0.697, 0.242, 0.674, 0.689, 0.215, 0.498, 0.679, 0.986, 0.510, 0.687,
+     0.980, 0.522, 0.696, 0.975, 0.534, 0.704, 0.970, 0.546, 0.712, 0.965,
+     0.558, 0.721, 0.961, 0.570, 0.729, 0.956, 0.581, 0.737, 0.952, 0.593,
+     0.746, 0.948, 0.605, 0.754, 0.945, 0.617, 0.762, 0.941, 0.629, 0.770,
+     0.938, 0.640, 0.778, 0.935, 0.652, 0.786, 0.932, 0.664, 0.794, 0.930,
+     0.675, 0.802, 0.927, 0.687, 0.810, 0.925, 0.698, 0.818, 0.923, 0.709,
+     0.826, 0.921, 0.720, 0.834, 0.919, 0.731, 0.841, 0.917, 0.742, 0.849,
+     0.915, 0.752, 0.856, 0.913, 0.762, 0.863, 0.911, 0.771, 0.870, 0.909,
+     0.780, 0.876, 0.907, 0.788, 0.882, 0.904, 0.796, 0.887, 0.901, 0.802,
+     0.892, 0.897, 0.807, 0.896, 0.893, 0.811, 0.899, 0.887, 0.814, 0.902,
+     0.880, 0.815, 0.903, 0.872, 0.815, 0.903, 0.862, 0.814, 0.902, 0.851,
+     0.812, 0.900, 0.838, 0.809, 0.897, 0.824, 0.805, 0.893, 0.808, 0.801,
+     0.889, 0.791, 0.796, 0.884, 0.774, 0.791, 0.878, 0.755, 0.786, 0.872,
+     0.735, 0.781, 0.865, 0.715, 0.776, 0.858, 0.695, 0.771, 0.851, 0.674,
+     0.767, 0.844, 0.653, 0.762, 0.836, 0.631, 0.757, 0.829, 0.610, 0.752,
+     0.821, 0.588, 0.748, 0.813, 0.566, 0.743, 0.805, 0.544, 0.739, 0.796,
+     0.522, 0.734, 0.788, 0.500, 0.730, 0.780, 0.477, 0.726, 0.772, 0.455,
+     0.722, 0.763, 0.432, 0.718, 0.755, 0.410, 0.714, 0.746, 0.387, 0.710,
+     0.738, 0.364, 0.706, 0.730, 0.340, 0.702, 0.721, 0.317, 0.698, 0.713,
+     0.293, 0.694, 0.704, 0.268, 0.691, 0.696, 0.243, 0.687, 0.687, 0.216,
+     0.513, 0.677, 0.987, 0.525, 0.686, 0.982, 0.537, 0.694, 0.977, 0.549,
+     0.703, 0.972, 0.561, 0.711, 0.967, 0.572, 0.720, 0.962, 0.584, 0.728,
+     0.958, 0.596, 0.737, 0.954, 0.608, 0.745, 0.951, 0.619, 0.753, 0.947,
+     0.631, 0.762, 0.944, 0.643, 0.770, 0.941, 0.655, 0.778, 0.938, 0.666,
+     0.787, 0.935, 0.678, 0.795, 0.933, 0.689, 0.803, 0.930, 0.701, 0.811,
+     0.928, 0.713, 0.820, 0.926, 0.724, 0.828, 0.925, 0.735, 0.836, 0.923,
+     0.746, 0.844, 0.921, 0.757, 0.852, 0.920, 0.768, 0.859, 0.918, 0.778,
+     0.867, 0.917, 0.788, 0.874, 0.915, 0.797, 0.881, 0.913, 0.806, 0.887,
+     0.911, 0.814, 0.893, 0.909, 0.821, 0.898, 0.906, 0.827, 0.902, 0.902,
+     0.831, 0.906, 0.897, 0.834, 0.908, 0.890, 0.836, 0.910, 0.882, 0.836,
+     0.910, 0.873, 0.834, 0.909, 0.861, 0.832, 0.906, 0.848, 0.828, 0.903,
+     0.833, 0.824, 0.899, 0.817, 0.819, 0.894, 0.799, 0.814, 0.888, 0.781,
+     0.809, 0.882, 0.761, 0.804, 0.875, 0.741, 0.798, 0.868, 0.720, 0.793,
+     0.861, 0.699, 0.788, 0.853, 0.678, 0.783, 0.845, 0.656, 0.777, 0.837,
+     0.635, 0.772, 0.829, 0.613, 0.768, 0.821, 0.590, 0.763, 0.813, 0.568,
+     0.758, 0.804, 0.546, 0.753, 0.796, 0.524, 0.749, 0.788, 0.501, 0.744,
+     0.779, 0.479, 0.740, 0.771, 0.456, 0.736, 0.762, 0.433, 0.731, 0.754,
+     0.411, 0.727, 0.745, 0.388, 0.723, 0.736, 0.365, 0.719, 0.728, 0.341,
+     0.715, 0.719, 0.317, 0.711, 0.711, 0.293, 0.707, 0.702, 0.268, 0.704,
+     0.694, 0.243, 0.700, 0.685, 0.216, 0.528, 0.675, 0.989, 0.540, 0.684,
+     0.983, 0.551, 0.693, 0.978, 0.563, 0.701, 0.973, 0.575, 0.710, 0.969,
+     0.586, 0.718, 0.964, 0.598, 0.727, 0.960, 0.610, 0.736, 0.956, 0.621,
+     0.744, 0.953, 0.633, 0.753, 0.949, 0.645, 0.761, 0.946, 0.656, 0.770,
+     0.943, 0.668, 0.778, 0.940, 0.680, 0.787, 0.938, 0.691, 0.795, 0.936,
+     0.703, 0.804, 0.933, 0.715, 0.812, 0.932, 0.726, 0.821, 0.930, 0.738,
+     0.829, 0.928, 0.749, 0.837, 0.927, 0.761, 0.846, 0.926, 0.772, 0.854,
+     0.924, 0.783, 0.862, 0.923, 0.794, 0.870, 0.922, 0.804, 0.877, 0.921,
+     0.814, 0.885, 0.920, 0.824, 0.892, 0.918, 0.832, 0.898, 0.917, 0.840,
+     0.904, 0.914, 0.846, 0.909, 0.911, 0.851, 0.913, 0.906, 0.855, 0.915,
+     0.901, 0.856, 0.917, 0.893, 0.856, 0.917, 0.883, 0.854, 0.915, 0.871,
+     0.851, 0.913, 0.858, 0.847, 0.909, 0.842, 0.842, 0.904, 0.825, 0.837,
+     0.898, 0.806, 0.831, 0.892, 0.787, 0.826, 0.885, 0.767, 0.820, 0.878,
+     0.746, 0.814, 0.870, 0.725, 0.809, 0.862, 0.703, 0.803, 0.854, 0.681,
+     0.798, 0.846, 0.659, 0.793, 0.838, 0.637, 0.788, 0.829, 0.615, 0.782,
+     0.821, 0.592, 0.777, 0.812, 0.570, 0.773, 0.804, 0.548, 0.768, 0.795,
+     0.525, 0.763, 0.787, 0.502, 0.758, 0.778, 0.480, 0.754, 0.769, 0.457,
+     0.749, 0.761, 0.434, 0.745, 0.752, 0.411, 0.741, 0.743, 0.388, 0.737,
+     0.735, 0.365, 0.732, 0.726, 0.342, 0.728, 0.717, 0.318, 0.724, 0.709,
+     0.293, 0.720, 0.700, 0.269, 0.716, 0.691, 0.243, 0.712, 0.683, 0.216,
+     0.542, 0.673, 0.990, 0.554, 0.682, 0.985, 0.565, 0.691, 0.980, 0.577,
+     0.700, 0.975, 0.588, 0.708, 0.970, 0.600, 0.717, 0.966, 0.611, 0.726,
+     0.962, 0.623, 0.734, 0.958, 0.634, 0.743, 0.955, 0.646, 0.752, 0.951,
+     0.657, 0.760, 0.948, 0.669, 0.769, 0.945, 0.681, 0.778, 0.943, 0.692,
+     0.786, 0.940, 0.704, 0.795, 0.938, 0.716, 0.804, 0.936, 0.728, 0.812,
+     0.934, 0.739, 0.821, 0.933, 0.751, 0.830, 0.932, 0.763, 0.838, 0.930,
+     0.774, 0.847, 0.929, 0.786, 0.856, 0.929, 0.797, 0.864, 0.928, 0.809,
+     0.873, 0.927, 0.819, 0.881, 0.927, 0.830, 0.889, 0.926, 0.840, 0.896,
+     0.925, 0.850, 0.903, 0.924, 0.858, 0.910, 0.922, 0.865, 0.915, 0.920,
+     0.871, 0.920, 0.916, 0.875, 0.923, 0.911, 0.876, 0.924, 0.903, 0.876,
+     0.924, 0.894, 0.873, 0.922, 0.882, 0.870, 0.919, 0.867, 0.865, 0.914,
+     0.851, 0.860, 0.909, 0.832, 0.854, 0.902, 0.813, 0.848, 0.895, 0.793,
+     0.842, 0.888, 0.772, 0.836, 0.880, 0.750, 0.830, 0.872, 0.729, 0.824,
+     0.864, 0.707, 0.819, 0.855, 0.684, 0.813, 0.847, 0.662, 0.808, 0.838,
+     0.639, 0.802, 0.829, 0.617, 0.797, 0.820, 0.594, 0.792, 0.812, 0.571,
+     0.787, 0.803, 0.549, 0.782, 0.794, 0.526, 0.777, 0.785, 0.503, 0.772,
+     0.776, 0.480, 0.767, 0.768, 0.458, 0.763, 0.759, 0.435, 0.758, 0.750,
+     0.412, 0.754, 0.741, 0.388, 0.749, 0.732, 0.365, 0.745, 0.724, 0.342,
+     0.741, 0.715, 0.318, 0.737, 0.706, 0.293, 0.732, 0.697, 0.269, 0.728,
+     0.689, 0.243, 0.724, 0.680, 0.216, 0.556, 0.671, 0.992, 0.567, 0.680,
+     0.986, 0.578, 0.689, 0.981, 0.590, 0.697, 0.976, 0.601, 0.706, 0.972,
+     0.612, 0.715, 0.968, 0.624, 0.724, 0.964, 0.635, 0.733, 0.960, 0.646,
+     0.741, 0.956, 0.658, 0.750, 0.953, 0.670, 0.759, 0.950, 0.681, 0.768,
+     0.947, 0.693, 0.777, 0.945, 0.704, 0.786, 0.943, 0.716, 0.794, 0.941,
+     0.728, 0.803, 0.939, 0.740, 0.812, 0.937, 0.752, 0.821, 0.936, 0.763,
+     0.830, 0.935, 0.775, 0.839, 0.934, 0.787, 0.848, 0.933, 0.799, 0.857,
+     0.932, 0.811, 0.866, 0.932, 0.822, 0.875, 0.932, 0.834, 0.883, 0.932,
+     0.845, 0.892, 0.931, 0.856, 0.900, 0.931, 0.866, 0.908, 0.931, 0.876,
+     0.915, 0.930, 0.884, 0.922, 0.929, 0.890, 0.927, 0.926, 0.895, 0.930,
+     0.921, 0.896, 0.932, 0.914, 0.896, 0.932, 0.905, 0.893, 0.929, 0.892,
+     0.888, 0.925, 0.876, 0.883, 0.920, 0.859, 0.877, 0.913, 0.840, 0.871,
+     0.906, 0.819, 0.864, 0.898, 0.798, 0.858, 0.890, 0.776, 0.852, 0.882,
+     0.754, 0.845, 0.873, 0.732, 0.839, 0.864, 0.709, 0.833, 0.855, 0.686,
+     0.828, 0.846, 0.664, 0.822, 0.837, 0.641, 0.816, 0.828, 0.618, 0.811,
+     0.819, 0.595, 0.806, 0.810, 0.572, 0.800, 0.801, 0.549, 0.795, 0.792,
+     0.526, 0.790, 0.783, 0.504, 0.785, 0.774, 0.481, 0.781, 0.765, 0.458,
+     0.776, 0.756, 0.435, 0.771, 0.748, 0.412, 0.766, 0.739, 0.388, 0.762,
+     0.730, 0.365, 0.757, 0.721, 0.341, 0.753, 0.712, 0.318, 0.749, 0.703,
+     0.293, 0.744, 0.695, 0.268, 0.740, 0.686, 0.243, 0.736, 0.677, 0.216,
+     0.569, 0.668, 0.993, 0.580, 0.677, 0.987, 0.591, 0.686, 0.982, 0.602,
+     0.695, 0.978, 0.613, 0.704, 0.973, 0.624, 0.713, 0.969, 0.635, 0.722,
+     0.965, 0.647, 0.731, 0.961, 0.658, 0.740, 0.958, 0.670, 0.748, 0.955,
+     0.681, 0.757, 0.952, 0.693, 0.766, 0.949, 0.704, 0.775, 0.947, 0.716,
+     0.784, 0.945, 0.728, 0.793, 0.943, 0.739, 0.802, 0.941, 0.751, 0.812,
+     0.939, 0.763, 0.821, 0.938, 0.775, 0.830, 0.937, 0.787, 0.839, 0.936,
+     0.799, 0.848, 0.936, 0.811, 0.858, 0.936, 0.823, 0.867, 0.935, 0.835,
+     0.876, 0.936, 0.847, 0.886, 0.936, 0.859, 0.895, 0.936, 0.870, 0.904,
+     0.937, 0.882, 0.912, 0.937, 0.892, 0.920, 0.937, 0.901, 0.928, 0.937,
+     0.909, 0.934, 0.936, 0.914, 0.938, 0.932, 0.917, 0.940, 0.926, 0.915,
+     0.940, 0.916, 0.912, 0.936, 0.902, 0.906, 0.931, 0.885, 0.900, 0.925,
+     0.866, 0.893, 0.917, 0.846, 0.887, 0.909, 0.824, 0.880, 0.900, 0.802,
+     0.873, 0.891, 0.780, 0.867, 0.882, 0.757, 0.860, 0.873, 0.734, 0.854,
+     0.864, 0.711, 0.848, 0.855, 0.688, 0.842, 0.845, 0.665, 0.836, 0.836,
+     0.642, 0.830, 0.827, 0.619, 0.824, 0.818, 0.596, 0.819, 0.808, 0.573,
+     0.814, 0.799, 0.549, 0.808, 0.790, 0.527, 0.803, 0.781, 0.504, 0.798,
+     0.772, 0.481, 0.793, 0.763, 0.458, 0.788, 0.754, 0.434, 0.783, 0.745,
+     0.411, 0.779, 0.736, 0.388, 0.774, 0.727, 0.365, 0.769, 0.718, 0.341,
+     0.765, 0.709, 0.317, 0.760, 0.700, 0.293, 0.756, 0.691, 0.268, 0.751,
+     0.683, 0.242, 0.747, 0.674, 0.215, 0.581, 0.665, 0.994, 0.592, 0.674,
+     0.989, 0.603, 0.683, 0.984, 0.614, 0.692, 0.979, 0.625, 0.701, 0.974,
+     0.636, 0.710, 0.970, 0.647, 0.719, 0.966, 0.658, 0.728, 0.963, 0.669,
+     0.737, 0.959, 0.681, 0.746, 0.956, 0.692, 0.755, 0.953, 0.703, 0.765,
+     0.951, 0.715, 0.774, 0.948, 0.727, 0.783, 0.946, 0.738, 0.792, 0.944,
+     0.750, 0.801, 0.943, 0.762, 0.810, 0.941, 0.774, 0.820, 0.940, 0.786,
+     0.829, 0.939, 0.798, 0.839, 0.939, 0.810, 0.848, 0.938, 0.822, 0.858,
+     0.938, 0.834, 0.867, 0.939, 0.847, 0.877, 0.939, 0.859, 0.887, 0.940,
+     0.871, 0.897, 0.940, 0.883, 0.906, 0.942, 0.896, 0.916, 0.943, 0.907,
+     0.925, 0.944, 0.918, 0.933, 0.945, 0.927, 0.941, 0.945, 0.934, 0.946,
+     0.943, 0.937, 0.949, 0.937, 0.935, 0.948, 0.927, 0.930, 0.943, 0.912,
+     0.924, 0.937, 0.893, 0.916, 0.929, 0.872, 0.909, 0.920, 0.850, 0.902,
+     0.911, 0.828, 0.895, 0.901, 0.805, 0.888, 0.892, 0.782, 0.881, 0.882,
+     0.759, 0.874, 0.872, 0.735, 0.868, 0.863, 0.712, 0.861, 0.853, 0.689,
+     0.855, 0.844, 0.665, 0.849, 0.834, 0.642, 0.843, 0.825, 0.619, 0.838,
+     0.815, 0.596, 0.832, 0.806, 0.572, 0.826, 0.797, 0.549, 0.821, 0.787,
+     0.526, 0.816, 0.778, 0.503, 0.811, 0.769, 0.480, 0.805, 0.760, 0.457,
+     0.800, 0.751, 0.434, 0.795, 0.742, 0.411, 0.791, 0.733, 0.387, 0.786,
+     0.724, 0.364, 0.781, 0.715, 0.340, 0.776, 0.706, 0.316, 0.772, 0.697,
+     0.292, 0.767, 0.688, 0.267, 0.762, 0.679, 0.241, 0.758, 0.670, 0.215,
+     0.593, 0.662, 0.995, 0.603, 0.671, 0.990, 0.614, 0.680, 0.985, 0.625,
+     0.689, 0.980, 0.636, 0.699, 0.975, 0.647, 0.708, 0.971, 0.658, 0.717,
+     0.967, 0.669, 0.726, 0.964, 0.680, 0.735, 0.960, 0.691, 0.744, 0.957,
+     0.702, 0.753, 0.955, 0.714, 0.762, 0.952, 0.725, 0.771, 0.950, 0.737,
+     0.781, 0.948, 0.748, 0.790, 0.946, 0.760, 0.799, 0.944, 0.772, 0.809,
+     0.943, 0.784, 0.818, 0.942, 0.796, 0.828, 0.941, 0.808, 0.837, 0.941,
+     0.820, 0.847, 0.940, 0.832, 0.857, 0.941, 0.844, 0.867, 0.941, 0.857,
+     0.877, 0.942, 0.869, 0.887, 0.943, 0.882, 0.897, 0.944, 0.895, 0.908,
+     0.945, 0.908, 0.918, 0.947, 0.920, 0.928, 0.949, 0.933, 0.938, 0.951,
+     0.944, 0.947, 0.953, 0.953, 0.955, 0.954, 0.957, 0.958, 0.950, 0.954,
+     0.956, 0.938, 0.948, 0.949, 0.920, 0.940, 0.941, 0.899, 0.932, 0.931,
+     0.877, 0.924, 0.921, 0.854, 0.916, 0.911, 0.830, 0.909, 0.901, 0.807,
+     0.901, 0.891, 0.783, 0.894, 0.881, 0.759, 0.887, 0.871, 0.736, 0.881,
+     0.861, 0.712, 0.874, 0.851, 0.688, 0.868, 0.841, 0.665, 0.862, 0.832,
+     0.642, 0.856, 0.822, 0.618, 0.850, 0.812, 0.595, 0.844, 0.803, 0.572,
+     0.839, 0.793, 0.549, 0.833, 0.784, 0.525, 0.828, 0.775, 0.502, 0.822,
+     0.766, 0.479, 0.817, 0.756, 0.456, 0.812, 0.747, 0.433, 0.807, 0.738,
+     0.410, 0.802, 0.729, 0.387, 0.797, 0.720, 0.363, 0.792, 0.711, 0.339,
+     0.787, 0.702, 0.315, 0.782, 0.693, 0.291, 0.778, 0.684, 0.266, 0.773,
+     0.675, 0.240, 0.768, 0.666, 0.214, 0.604, 0.659, 0.996, 0.614, 0.668,
+     0.990, 0.625, 0.677, 0.985, 0.636, 0.686, 0.981, 0.646, 0.695, 0.976,
+     0.657, 0.704, 0.972, 0.668, 0.714, 0.968, 0.679, 0.723, 0.965, 0.690,
+     0.732, 0.961, 0.701, 0.741, 0.958, 0.712, 0.750, 0.956, 0.723, 0.759,
+     0.953, 0.735, 0.769, 0.951, 0.746, 0.778, 0.949, 0.758, 0.787, 0.947,
+     0.769, 0.797, 0.945, 0.781, 0.806, 0.944, 0.793, 0.816, 0.943, 0.805,
+     0.826, 0.943, 0.817, 0.836, 0.942, 0.829, 0.845, 0.942, 0.841, 0.855,
+     0.942, 0.853, 0.866, 0.943, 0.866, 0.876, 0.943, 0.879, 0.886, 0.945,
+     0.892, 0.897, 0.946, 0.905, 0.907, 0.948, 0.918, 0.918, 0.950, 0.931,
+     0.930, 0.953, 0.945, 0.941, 0.956, 0.958, 0.952, 0.960, 0.971, 0.963,
+     0.963, 0.978, 0.968, 0.963, 0.972, 0.963, 0.948, 0.963, 0.954, 0.926,
+     0.954, 0.943, 0.903, 0.945, 0.931, 0.879, 0.937, 0.921, 0.855, 0.929,
+     0.910, 0.831, 0.921, 0.899, 0.807, 0.914, 0.889, 0.783, 0.907, 0.878,
+     0.759, 0.900, 0.868, 0.735, 0.893, 0.858, 0.711, 0.887, 0.848, 0.688,
+     0.880, 0.838, 0.664, 0.874, 0.828, 0.641, 0.868, 0.818, 0.617, 0.862,
+     0.809, 0.594, 0.856, 0.799, 0.571, 0.850, 0.790, 0.547, 0.845, 0.780,
+     0.524, 0.839, 0.771, 0.501, 0.834, 0.762, 0.478, 0.828, 0.752, 0.455,
+     0.823, 0.743, 0.432, 0.818, 0.734, 0.409, 0.813, 0.725, 0.385, 0.808,
+     0.716, 0.362, 0.803, 0.707, 0.338, 0.798, 0.698, 0.314, 0.793, 0.689,
+     0.290, 0.788, 0.680, 0.265, 0.783, 0.671, 0.239, 0.778, 0.662, 0.213,
+     0.615, 0.655, 0.996, 0.625, 0.664, 0.991, 0.635, 0.673, 0.986, 0.646,
+     0.683, 0.982, 0.656, 0.692, 0.977, 0.667, 0.701, 0.973, 0.678, 0.710,
+     0.969, 0.688, 0.719, 0.966, 0.699, 0.729, 0.962, 0.710, 0.738, 0.959,
+     0.721, 0.747, 0.956, 0.732, 0.756, 0.954, 0.744, 0.766, 0.952, 0.755,
+     0.775, 0.950, 0.766, 0.784, 0.948, 0.778, 0.794, 0.946, 0.789, 0.804,
+     0.945, 0.801, 0.813, 0.944, 0.813, 0.823, 0.943, 0.825, 0.833, 0.943,
+     0.837, 0.843, 0.943, 0.849, 0.853, 0.943, 0.861, 0.863, 0.944, 0.874,
+     0.873, 0.944, 0.886, 0.884, 0.946, 0.899, 0.895, 0.947, 0.912, 0.906,
+     0.949, 0.926, 0.917, 0.952, 0.939, 0.928, 0.955, 0.953, 0.940, 0.958,
+     0.967, 0.953, 0.963, 0.982, 0.966, 0.969, 0.994, 0.976, 0.972, 0.986,
+     0.966, 0.952, 0.976, 0.953, 0.928, 0.966, 0.941, 0.903, 0.957, 0.929,
+     0.878, 0.949, 0.918, 0.854, 0.941, 0.906, 0.830, 0.933, 0.896, 0.806,
+     0.926, 0.885, 0.782, 0.918, 0.874, 0.758, 0.911, 0.864, 0.734, 0.905,
+     0.854, 0.710, 0.898, 0.844, 0.686, 0.892, 0.834, 0.663, 0.885, 0.824,
+     0.639, 0.879, 0.814, 0.616, 0.873, 0.804, 0.592, 0.867, 0.795, 0.569,
+     0.861, 0.785, 0.546, 0.856, 0.776, 0.523, 0.850, 0.766, 0.500, 0.845,
+     0.757, 0.477, 0.839, 0.748, 0.454, 0.834, 0.739, 0.430, 0.829, 0.729,
+     0.407, 0.823, 0.720, 0.384, 0.818, 0.711, 0.361, 0.813, 0.702, 0.337,
+     0.808, 0.693, 0.313, 0.803, 0.684, 0.289, 0.798, 0.675, 0.264, 0.793,
+     0.666, 0.238, 0.788, 0.657, 0.211, 0.625, 0.651, 0.997, 0.635, 0.660,
+     0.992, 0.645, 0.669, 0.987, 0.656, 0.679, 0.982, 0.666, 0.688, 0.978,
+     0.676, 0.697, 0.974, 0.687, 0.706, 0.970, 0.698, 0.716, 0.966, 0.708,
+     0.725, 0.963, 0.719, 0.734, 0.960, 0.730, 0.743, 0.957, 0.741, 0.753,
+     0.954, 0.752, 0.762, 0.952, 0.763, 0.771, 0.950, 0.774, 0.781, 0.948,
+     0.786, 0.790, 0.947, 0.797, 0.800, 0.945, 0.809, 0.810, 0.945, 0.820,
+     0.819, 0.944, 0.832, 0.829, 0.943, 0.844, 0.839, 0.943, 0.856, 0.849,
+     0.943, 0.868, 0.860, 0.944, 0.880, 0.870, 0.945, 0.893, 0.880, 0.946,
+     0.905, 0.891, 0.947, 0.918, 0.902, 0.949, 0.931, 0.913, 0.951, 0.944,
+     0.924, 0.954, 0.957, 0.936, 0.957, 0.971, 0.947, 0.961, 0.983, 0.958,
+     0.964, 0.991, 0.963, 0.962, 0.990, 0.957, 0.946, 0.983, 0.946, 0.924,
+     0.975, 0.935, 0.900, 0.967, 0.923, 0.876, 0.959, 0.912, 0.851, 0.951,
+     0.901, 0.827, 0.943, 0.890, 0.803, 0.936, 0.880, 0.779, 0.929, 0.869,
+     0.755, 0.922, 0.859, 0.732, 0.915, 0.849, 0.708, 0.909, 0.839, 0.684,
+     0.902, 0.829, 0.661, 0.896, 0.819, 0.637, 0.890, 0.809, 0.614, 0.884,
+     0.800, 0.591, 0.878, 0.790, 0.567, 0.872, 0.780, 0.544, 0.866, 0.771,
+     0.521, 0.861, 0.762, 0.498, 0.855, 0.752, 0.475, 0.850, 0.743, 0.452,
+     0.844, 0.734, 0.429, 0.839, 0.725, 0.406, 0.834, 0.715, 0.382, 0.828,
+     0.706, 0.359, 0.823, 0.697, 0.335, 0.818, 0.688, 0.311, 0.813, 0.679,
+     0.287, 0.808, 0.670, 0.262, 0.803, 0.662, 0.236, 0.798, 0.653, 0.210,
+     0.635, 0.646, 0.998, 0.645, 0.656, 0.992, 0.655, 0.665, 0.987, 0.665,
+     0.674, 0.983, 0.675, 0.684, 0.978, 0.685, 0.693, 0.974, 0.696, 0.702,
+     0.970, 0.706, 0.711, 0.966, 0.717, 0.721, 0.963, 0.727, 0.730, 0.960,
+     0.738, 0.739, 0.957, 0.749, 0.748, 0.955, 0.760, 0.758, 0.952, 0.771,
+     0.767, 0.950, 0.782, 0.777, 0.948, 0.793, 0.786, 0.947, 0.804, 0.796,
+     0.946, 0.816, 0.805, 0.945, 0.827, 0.815, 0.944, 0.839, 0.825, 0.943,
+     0.850, 0.835, 0.943, 0.862, 0.845, 0.943, 0.874, 0.855, 0.943, 0.886,
+     0.865, 0.944, 0.898, 0.875, 0.945, 0.910, 0.886, 0.946, 0.923, 0.896,
+     0.948, 0.935, 0.907, 0.949, 0.947, 0.917, 0.951, 0.959, 0.927, 0.953,
+     0.970, 0.937, 0.955, 0.980, 0.944, 0.955, 0.987, 0.946, 0.949, 0.989,
+     0.942, 0.936, 0.985, 0.935, 0.916, 0.980, 0.925, 0.894, 0.973, 0.915,
+     0.871, 0.966, 0.904, 0.847, 0.959, 0.894, 0.824, 0.952, 0.883, 0.800,
+     0.945, 0.873, 0.776, 0.938, 0.863, 0.752, 0.932, 0.853, 0.729, 0.925,
+     0.843, 0.705, 0.919, 0.833, 0.682, 0.912, 0.823, 0.658, 0.906, 0.813,
+     0.635, 0.900, 0.803, 0.611, 0.894, 0.794, 0.588, 0.888, 0.784, 0.565,
+     0.882, 0.775, 0.542, 0.876, 0.765, 0.519, 0.871, 0.756, 0.496, 0.865,
+     0.747, 0.473, 0.859, 0.738, 0.450, 0.854, 0.728, 0.427, 0.848, 0.719,
+     0.404, 0.843, 0.710, 0.380, 0.838, 0.701, 0.357, 0.833, 0.692, 0.333,
+     0.827, 0.683, 0.310, 0.822, 0.674, 0.285, 0.817, 0.665, 0.260, 0.812,
+     0.656, 0.235, 0.807, 0.648, 0.208, 0.644, 0.642, 0.998, 0.654, 0.651,
+     0.993, 0.664, 0.660, 0.988, 0.674, 0.670, 0.983, 0.684, 0.679, 0.978,
+     0.694, 0.688, 0.974, 0.704, 0.697, 0.970, 0.715, 0.707, 0.967, 0.725,
+     0.716, 0.963, 0.735, 0.725, 0.960, 0.746, 0.735, 0.957, 0.757, 0.744,
+     0.955, 0.767, 0.753, 0.952, 0.778, 0.763, 0.950, 0.789, 0.772, 0.948,
+     0.800, 0.781, 0.947, 0.811, 0.791, 0.945, 0.822, 0.801, 0.944, 0.833,
+     0.810, 0.943, 0.845, 0.820, 0.943, 0.856, 0.830, 0.942, 0.868, 0.839,
+     0.942, 0.879, 0.849, 0.942, 0.891, 0.859, 0.943, 0.902, 0.869, 0.943,
+     0.914, 0.879, 0.944, 0.926, 0.889, 0.945, 0.937, 0.899, 0.946, 0.949,
+     0.908, 0.947, 0.959, 0.917, 0.948, 0.969, 0.924, 0.947, 0.978, 0.929,
+     0.944, 0.984, 0.930, 0.937, 0.986, 0.927, 0.924, 0.986, 0.921, 0.907,
+     0.982, 0.913, 0.887, 0.978, 0.904, 0.865, 0.972, 0.895, 0.842, 0.966,
+     0.885, 0.819, 0.959, 0.875, 0.795, 0.953, 0.865, 0.772, 0.946, 0.855,
+     0.749, 0.940, 0.846, 0.725, 0.934, 0.836, 0.702, 0.927, 0.826, 0.678,
+     0.921, 0.816, 0.655, 0.915, 0.807, 0.632, 0.909, 0.797, 0.609, 0.903,
+     0.788, 0.586, 0.897, 0.778, 0.562, 0.891, 0.769, 0.539, 0.886, 0.759,
+     0.516, 0.880, 0.750, 0.493, 0.874, 0.741, 0.471, 0.869, 0.732, 0.448,
+     0.863, 0.723, 0.425, 0.858, 0.713, 0.402, 0.852, 0.704, 0.378, 0.847,
+     0.695, 0.355, 0.842, 0.686, 0.331, 0.836, 0.677, 0.308, 0.831, 0.669,
+     0.283, 0.826, 0.660, 0.258, 0.821, 0.651, 0.233, 0.815, 0.642, 0.206,
+     0.653, 0.636, 0.998, 0.663, 0.646, 0.993, 0.673, 0.655, 0.988, 0.682,
+     0.665, 0.983, 0.692, 0.674, 0.979, 0.702, 0.683, 0.974, 0.712, 0.692,
+     0.970, 0.722, 0.702, 0.967, 0.733, 0.711, 0.963, 0.743, 0.720, 0.960,
+     0.753, 0.730, 0.957, 0.764, 0.739, 0.954, 0.774, 0.748, 0.952, 0.785,
+     0.757, 0.950, 0.796, 0.767, 0.948, 0.806, 0.776, 0.946, 0.817, 0.786,
+     0.945, 0.828, 0.795, 0.943, 0.839, 0.804, 0.942, 0.850, 0.814, 0.941,
+     0.861, 0.824, 0.941, 0.872, 0.833, 0.940, 0.884, 0.843, 0.940, 0.895,
+     0.852, 0.940, 0.906, 0.862, 0.940, 0.917, 0.871, 0.941, 0.928, 0.880,
+     0.941, 0.939, 0.889, 0.941, 0.949, 0.897, 0.941, 0.959, 0.904, 0.940,
+     0.968, 0.910, 0.938, 0.975, 0.914, 0.933, 0.981, 0.914, 0.925, 0.984,
+     0.912, 0.913, 0.985, 0.907, 0.897, 0.983, 0.900, 0.878, 0.980, 0.893,
+     0.857, 0.976, 0.884, 0.836, 0.971, 0.875, 0.813, 0.965, 0.866, 0.790,
+     0.959, 0.856, 0.767, 0.954, 0.847, 0.744, 0.947, 0.837, 0.721, 0.941,
+     0.828, 0.698, 0.935, 0.818, 0.675, 0.929, 0.809, 0.652, 0.923, 0.800,
+     0.629, 0.917, 0.790, 0.605, 0.912, 0.781, 0.582, 0.906, 0.771, 0.560,
+     0.900, 0.762, 0.537, 0.894, 0.753, 0.514, 0.889, 0.744, 0.491, 0.883,
+     0.735, 0.468, 0.877, 0.725, 0.445, 0.872, 0.716, 0.422, 0.866, 0.707,
+     0.399, 0.861, 0.698, 0.376, 0.856, 0.689, 0.353, 0.850, 0.680, 0.329,
+     0.845, 0.672, 0.305, 0.840, 0.663, 0.281, 0.834, 0.654, 0.256, 0.829,
+     0.645, 0.231, 0.824, 0.636, 0.204, 0.662, 0.631, 0.998, 0.672, 0.641,
+     0.993, 0.681, 0.650, 0.988, 0.691, 0.659, 0.983, 0.700, 0.669, 0.979,
+     0.710, 0.678, 0.974, 0.720, 0.687, 0.970, 0.730, 0.696, 0.966, 0.740,
+     0.706, 0.963, 0.750, 0.715, 0.960, 0.760, 0.724, 0.957, 0.771, 0.733,
+     0.954, 0.781, 0.742, 0.951, 0.791, 0.752, 0.949, 0.802, 0.761, 0.947,
+     0.812, 0.770, 0.945, 0.823, 0.779, 0.943, 0.834, 0.789, 0.942, 0.844,
+     0.798, 0.941, 0.855, 0.807, 0.940, 0.866, 0.817, 0.939, 0.877, 0.826,
+     0.938, 0.887, 0.835, 0.938, 0.898, 0.844, 0.937, 0.909, 0.853, 0.937,
+     0.919, 0.862, 0.937, 0.930, 0.870, 0.936, 0.940, 0.878, 0.936, 0.950,
+     0.885, 0.934, 0.958, 0.891, 0.932, 0.967, 0.896, 0.928, 0.974, 0.898,
+     0.922, 0.979, 0.899, 0.914, 0.982, 0.897, 0.902, 0.984, 0.893, 0.886,
+     0.984, 0.887, 0.869, 0.982, 0.880, 0.849, 0.979, 0.872, 0.828, 0.975,
+     0.864, 0.807, 0.970, 0.856, 0.785, 0.965, 0.847, 0.762, 0.959, 0.838,
+     0.739, 0.954, 0.829, 0.717, 0.948, 0.819, 0.694, 0.943, 0.810, 0.671,
+     0.937, 0.801, 0.648, 0.931, 0.792, 0.625, 0.925, 0.782, 0.602, 0.919,
+     0.773, 0.579, 0.914, 0.764, 0.556, 0.908, 0.755, 0.533, 0.902, 0.746,
+     0.511, 0.897, 0.737, 0.488, 0.891, 0.728, 0.465, 0.886, 0.719, 0.442,
+     0.880, 0.710, 0.420, 0.875, 0.701, 0.397, 0.869, 0.692, 0.374, 0.864,
+     0.683, 0.350, 0.858, 0.674, 0.327, 0.853, 0.665, 0.303, 0.848, 0.657,
+     0.279, 0.842, 0.648, 0.254, 0.837, 0.639, 0.229, 0.832, 0.630, 0.202,
+     0.671, 0.625, 0.998, 0.680, 0.635, 0.993, 0.689, 0.644, 0.988, 0.698,
+     0.654, 0.983, 0.708, 0.663, 0.978, 0.718, 0.672, 0.974, 0.727, 0.681,
+     0.970, 0.737, 0.691, 0.966, 0.747, 0.700, 0.962, 0.757, 0.709, 0.959,
+     0.767, 0.718, 0.956, 0.777, 0.727, 0.953, 0.787, 0.736, 0.950, 0.797,
+     0.745, 0.948, 0.807, 0.755, 0.946, 0.818, 0.764, 0.944, 0.828, 0.773,
+     0.942, 0.839, 0.782, 0.940, 0.849, 0.791, 0.939, 0.859, 0.800, 0.938,
+     0.870, 0.809, 0.937, 0.880, 0.818, 0.936, 0.891, 0.827, 0.935, 0.901,
+     0.835, 0.934, 0.911, 0.844, 0.933, 0.921, 0.852, 0.932, 0.931, 0.859,
+     0.931, 0.941, 0.866, 0.929, 0.950, 0.873, 0.927, 0.958, 0.878, 0.923,
+     0.966, 0.881, 0.919, 0.972, 0.883, 0.912, 0.977, 0.883, 0.903, 0.981,
+     0.882, 0.891, 0.983, 0.878, 0.876, 0.984, 0.873, 0.859, 0.983, 0.867,
+     0.841, 0.980, 0.860, 0.821, 0.977, 0.853, 0.800, 0.974, 0.845, 0.778,
+     0.969, 0.836, 0.756, 0.964, 0.828, 0.734, 0.959, 0.819, 0.712, 0.954,
+     0.810, 0.689, 0.949, 0.801, 0.666, 0.943, 0.792, 0.644, 0.938, 0.783,
+     0.621, 0.932, 0.774, 0.598, 0.927, 0.765, 0.575, 0.921, 0.756, 0.553,
+     0.916, 0.747, 0.530, 0.910, 0.738, 0.507, 0.904, 0.729, 0.485, 0.899,
+     0.721, 0.462, 0.893, 0.712, 0.439, 0.888, 0.703, 0.417, 0.882, 0.694,
+     0.394, 0.877, 0.685, 0.371, 0.871, 0.676, 0.348, 0.866, 0.668, 0.324,
+     0.861, 0.659, 0.301, 0.855, 0.650, 0.277, 0.850, 0.641, 0.252, 0.845,
+     0.633, 0.226, 0.839, 0.624, 0.200, 0.679, 0.619, 0.998, 0.688, 0.629,
+     0.993, 0.697, 0.638, 0.988, 0.706, 0.648, 0.983, 0.715, 0.657, 0.978,
+     0.725, 0.666, 0.974, 0.734, 0.675, 0.969, 0.744, 0.684, 0.965, 0.754,
+     0.693, 0.962, 0.763, 0.703, 0.958, 0.773, 0.712, 0.955, 0.783, 0.721,
+     0.952, 0.793, 0.730, 0.949, 0.803, 0.739, 0.947, 0.813, 0.748, 0.944,
+     0.823, 0.757, 0.942, 0.833, 0.766, 0.940, 0.843, 0.774, 0.938, 0.853,
+     0.783, 0.937, 0.863, 0.792, 0.935, 0.874, 0.801, 0.934, 0.884, 0.809,
+     0.932, 0.894, 0.818, 0.931, 0.904, 0.826, 0.930, 0.913, 0.833, 0.928,
+     0.923, 0.841, 0.927, 0.932, 0.848, 0.925, 0.941, 0.854, 0.922, 0.950,
+     0.859, 0.919, 0.957, 0.864, 0.915, 0.965, 0.867, 0.909, 0.971, 0.868,
+     0.901, 0.976, 0.868, 0.892, 0.980, 0.867, 0.880, 0.982, 0.863, 0.866,
+     0.983, 0.859, 0.849, 0.983, 0.854, 0.832, 0.982, 0.847, 0.812, 0.979,
+     0.840, 0.792, 0.976, 0.833, 0.771, 0.973, 0.825, 0.750, 0.969, 0.817,
+     0.728, 0.964, 0.809, 0.706, 0.959, 0.800, 0.684, 0.954, 0.792, 0.661,
+     0.949, 0.783, 0.639, 0.944, 0.774, 0.617, 0.939, 0.766, 0.594, 0.933,
+     0.757, 0.572, 0.928, 0.748, 0.549, 0.922, 0.739, 0.527, 0.917, 0.731,
+     0.504, 0.911, 0.722, 0.481, 0.906, 0.713, 0.459, 0.901, 0.704, 0.436,
+     0.895, 0.695, 0.414, 0.890, 0.687, 0.391, 0.884, 0.678, 0.368, 0.879,
+     0.669, 0.345, 0.873, 0.661, 0.322, 0.868, 0.652, 0.298, 0.863, 0.643,
+     0.274, 0.857, 0.635, 0.249, 0.852, 0.626, 0.224, 0.846, 0.617, 0.197,
+     0.686, 0.613, 0.998, 0.695, 0.622, 0.993, 0.704, 0.632, 0.987, 0.713,
+     0.641, 0.982, 0.722, 0.650, 0.977, 0.732, 0.660, 0.973, 0.741, 0.669,
+     0.969, 0.750, 0.678, 0.965, 0.760, 0.687, 0.961, 0.769, 0.696, 0.957,
+     0.779, 0.705, 0.954, 0.789, 0.714, 0.951, 0.798, 0.723, 0.948, 0.808,
+     0.731, 0.945, 0.818, 0.740, 0.943, 0.828, 0.749, 0.940, 0.838, 0.758,
+     0.938, 0.847, 0.766, 0.936, 0.857, 0.775, 0.934, 0.867, 0.783, 0.932,
+     0.877, 0.792, 0.930, 0.887, 0.800, 0.929, 0.896, 0.808, 0.927, 0.906,
+     0.815, 0.925, 0.915, 0.823, 0.923, 0.924, 0.829, 0.921, 0.933, 0.836,
+     0.918, 0.942, 0.841, 0.915, 0.950, 0.846, 0.911, 0.957, 0.850, 0.906,
+     0.964, 0.852, 0.899, 0.970, 0.853, 0.891, 0.975, 0.853, 0.881, 0.979,
+     0.852, 0.869, 0.981, 0.849, 0.855, 0.983, 0.845, 0.840, 0.983, 0.840,
+     0.822, 0.982, 0.834, 0.804, 0.981, 0.828, 0.784, 0.978, 0.821, 0.764,
+     0.975, 0.814, 0.743, 0.972, 0.806, 0.722, 0.968, 0.798, 0.700, 0.964,
+     0.790, 0.678, 0.959, 0.782, 0.656, 0.954, 0.773, 0.634, 0.949, 0.765,
+     0.612, 0.944, 0.757, 0.590, 0.939, 0.748, 0.567, 0.934, 0.739, 0.545,
+     0.929, 0.731, 0.523, 0.923, 0.722, 0.500, 0.918, 0.714, 0.478, 0.913,
+     0.705, 0.456, 0.907, 0.696, 0.433, 0.902, 0.688, 0.411, 0.896, 0.679,
+     0.388, 0.891, 0.670, 0.365, 0.886, 0.662, 0.342, 0.880, 0.653, 0.319,
+     0.875, 0.645, 0.295, 0.869, 0.636, 0.271, 0.864, 0.628, 0.247, 0.859,
+     0.619, 0.221, 0.853, 0.611, 0.195, 0.694, 0.606, 0.998, 0.703, 0.616,
+     0.992, 0.711, 0.625, 0.987, 0.720, 0.634, 0.982, 0.729, 0.644, 0.977,
+     0.738, 0.653, 0.972, 0.747, 0.662, 0.968, 0.757, 0.671, 0.964, 0.766,
+     0.680, 0.960, 0.775, 0.689, 0.956, 0.785, 0.698, 0.953, 0.794, 0.706,
+     0.949, 0.804, 0.715, 0.946, 0.813, 0.724, 0.943, 0.823, 0.732, 0.941,
+     0.832, 0.741, 0.938, 0.842, 0.749, 0.936, 0.851, 0.758, 0.933, 0.861,
+     0.766, 0.931, 0.870, 0.774, 0.929, 0.880, 0.782, 0.927, 0.889, 0.790,
+     0.924, 0.899, 0.797, 0.922, 0.908, 0.805, 0.920, 0.917, 0.811, 0.917,
+     0.925, 0.818, 0.914, 0.934, 0.823, 0.911, 0.942, 0.828, 0.907, 0.950,
+     0.832, 0.902, 0.957, 0.836, 0.896, 0.963, 0.838, 0.889, 0.969, 0.839,
+     0.881, 0.974, 0.838, 0.871, 0.978, 0.837, 0.859, 0.980, 0.834, 0.845,
+     0.982, 0.831, 0.830, 0.983, 0.826, 0.813, 0.983, 0.821, 0.795, 0.982,
+     0.815, 0.776, 0.980, 0.809, 0.757, 0.978, 0.802, 0.736, 0.975, 0.794,
+     0.715, 0.971, 0.787, 0.694, 0.967, 0.779, 0.673, 0.963, 0.771, 0.651,
+     0.959, 0.763, 0.629, 0.954, 0.755, 0.607, 0.949, 0.747, 0.585, 0.944,
+     0.739, 0.563, 0.939, 0.730, 0.541, 0.934, 0.722, 0.519, 0.929, 0.714,
+     0.496, 0.924, 0.705, 0.474, 0.919, 0.697, 0.452, 0.913, 0.688, 0.430,
+     0.908, 0.680, 0.407, 0.903, 0.671, 0.385, 0.897, 0.663, 0.362, 0.892,
+     0.654, 0.339, 0.887, 0.646, 0.316, 0.881, 0.637, 0.293, 0.876, 0.629,
+     0.269, 0.870, 0.620, 0.244, 0.865, 0.612, 0.219, 0.860, 0.604, 0.192,
+     0.701, 0.599, 0.997, 0.710, 0.609, 0.992, 0.718, 0.618, 0.986, 0.727,
+     0.627, 0.981, 0.736, 0.636, 0.976, 0.745, 0.645, 0.971, 0.754, 0.655,
+     0.967, 0.763, 0.663, 0.963, 0.772, 0.672, 0.959, 0.781, 0.681, 0.955,
+     0.790, 0.690, 0.951, 0.799, 0.699, 0.948, 0.808, 0.707, 0.944, 0.818,
+     0.716, 0.941, 0.827, 0.724, 0.938, 0.836, 0.732, 0.935, 0.846, 0.741,
+     0.933, 0.855, 0.749, 0.930, 0.864, 0.757, 0.928, 0.874, 0.765, 0.925,
+     0.883, 0.772, 0.923, 0.892, 0.780, 0.920, 0.901, 0.787, 0.917, 0.910,
+     0.793, 0.914, 0.918, 0.800, 0.911, 0.927, 0.805, 0.908, 0.935, 0.811,
+     0.904, 0.942, 0.815, 0.899, 0.950, 0.819, 0.894, 0.956, 0.821, 0.887,
+     0.963, 0.823, 0.880, 0.968, 0.824, 0.871, 0.973, 0.824, 0.860, 0.977,
+     0.822, 0.849, 0.980, 0.820, 0.835, 0.982, 0.817, 0.820, 0.983, 0.812,
+     0.804, 0.983, 0.808, 0.786, 0.983, 0.802, 0.768, 0.981, 0.796, 0.749,
+     0.979, 0.789, 0.729, 0.977, 0.783, 0.709, 0.974, 0.776, 0.688, 0.970,
+     0.768, 0.667, 0.967, 0.761, 0.645, 0.963, 0.753, 0.624, 0.958, 0.745,
+     0.602, 0.954, 0.737, 0.580, 0.949, 0.729, 0.558, 0.944, 0.721, 0.536,
+     0.939, 0.713, 0.514, 0.934, 0.704, 0.492, 0.929, 0.696, 0.470, 0.924,
+     0.688, 0.448, 0.919, 0.680, 0.426, 0.914, 0.671, 0.404, 0.908, 0.663,
+     0.381, 0.903, 0.655, 0.359, 0.898, 0.646, 0.336, 0.893, 0.638, 0.313,
+     0.887, 0.629, 0.290, 0.882, 0.621, 0.266, 0.876, 0.613, 0.241, 0.871,
+     0.604, 0.216, 0.866, 0.596, 0.189, 0.708, 0.592, 0.997, 0.716, 0.601,
+     0.991, 0.725, 0.611, 0.985, 0.733, 0.620, 0.980, 0.742, 0.629, 0.975,
+     0.751, 0.638, 0.970, 0.759, 0.647, 0.966, 0.768, 0.656, 0.961, 0.777,
+     0.665, 0.957, 0.786, 0.673, 0.953, 0.795, 0.682, 0.949, 0.804, 0.690,
+     0.946, 0.813, 0.699, 0.942, 0.822, 0.707, 0.939, 0.831, 0.715, 0.936,
+     0.840, 0.723, 0.933, 0.849, 0.731, 0.930, 0.859, 0.739, 0.927, 0.868,
+     0.747, 0.924, 0.876, 0.754, 0.921, 0.885, 0.762, 0.918, 0.894, 0.769,
+     0.915, 0.903, 0.775, 0.912, 0.911, 0.782, 0.909, 0.920, 0.787, 0.905,
+     0.928, 0.793, 0.901, 0.935, 0.798, 0.896, 0.943, 0.802, 0.891, 0.950,
+     0.805, 0.885, 0.956, 0.807, 0.878, 0.962, 0.809, 0.870, 0.967, 0.809,
+     0.861, 0.972, 0.809, 0.850, 0.976, 0.808, 0.838, 0.979, 0.805, 0.825,
+     0.981, 0.802, 0.810, 0.983, 0.799, 0.795, 0.983, 0.794, 0.778, 0.983,
+     0.789, 0.760, 0.982, 0.783, 0.741, 0.981, 0.777, 0.721, 0.979, 0.771,
+     0.701, 0.976, 0.764, 0.681, 0.973, 0.757, 0.660, 0.970, 0.750, 0.639,
+     0.966, 0.742, 0.618, 0.962, 0.735, 0.597, 0.958, 0.727, 0.575, 0.953,
+     0.719, 0.553, 0.949, 0.711, 0.532, 0.944, 0.703, 0.510, 0.939, 0.695,
+     0.488, 0.934, 0.687, 0.466, 0.929, 0.679, 0.444, 0.924, 0.671, 0.422,
+     0.919, 0.663, 0.400, 0.914, 0.654, 0.378, 0.909, 0.646, 0.355, 0.903,
+     0.638, 0.333, 0.898, 0.630, 0.310, 0.893, 0.621, 0.287, 0.887, 0.613,
+     0.263, 0.882, 0.605, 0.238, 0.877, 0.597, 0.213, 0.871, 0.589, 0.186,
+     0.715, 0.584, 0.996, 0.723, 0.593, 0.990, 0.731, 0.603, 0.984, 0.739,
+     0.612, 0.979, 0.748, 0.621, 0.974, 0.756, 0.630, 0.969, 0.765, 0.639,
+     0.964, 0.774, 0.648, 0.960, 0.782, 0.656, 0.955, 0.791, 0.665, 0.951,
+     0.800, 0.673, 0.947, 0.809, 0.682, 0.943, 0.818, 0.690, 0.940, 0.826,
+     0.698, 0.936, 0.835, 0.706, 0.933, 0.844, 0.714, 0.930, 0.853, 0.722,
+     0.926, 0.862, 0.729, 0.923, 0.871, 0.737, 0.920, 0.879, 0.744, 0.917,
+     0.888, 0.751, 0.913, 0.896, 0.758, 0.910, 0.905, 0.764, 0.906, 0.913,
+     0.770, 0.903, 0.921, 0.775, 0.898, 0.929, 0.780, 0.894, 0.936, 0.784,
+     0.889, 0.943, 0.788, 0.883, 0.950, 0.791, 0.877, 0.956, 0.793, 0.869,
+     0.962, 0.794, 0.861, 0.967, 0.795, 0.851, 0.971, 0.794, 0.841, 0.975,
+     0.793, 0.829, 0.978, 0.791, 0.815, 0.981, 0.788, 0.801, 0.982, 0.785,
+     0.785, 0.983, 0.780, 0.769, 0.983, 0.776, 0.751, 0.983, 0.770, 0.733,
+     0.982, 0.764, 0.714, 0.980, 0.758, 0.694, 0.978, 0.752, 0.674, 0.975,
+     0.745, 0.654, 0.972, 0.738, 0.633, 0.969, 0.731, 0.612, 0.965, 0.724,
+     0.591, 0.961, 0.716, 0.570, 0.957, 0.709, 0.548, 0.953, 0.701, 0.527,
+     0.948, 0.693, 0.505, 0.943, 0.685, 0.484, 0.939, 0.678, 0.462, 0.934,
+     0.670, 0.440, 0.929, 0.662, 0.418, 0.924, 0.654, 0.396, 0.919, 0.646,
+     0.374, 0.914, 0.637, 0.352, 0.908, 0.629, 0.329, 0.903, 0.621, 0.307,
+     0.898, 0.613, 0.283, 0.893, 0.605, 0.260, 0.887, 0.597, 0.235, 0.882,
+     0.589, 0.210, 0.876, 0.581, 0.183, 0.721, 0.576, 0.995, 0.729, 0.585,
+     0.989, 0.737, 0.595, 0.983, 0.745, 0.604, 0.978, 0.754, 0.613, 0.973,
+     0.762, 0.622, 0.968, 0.770, 0.631, 0.963, 0.779, 0.639, 0.958, 0.787,
+     0.648, 0.954, 0.796, 0.656, 0.949, 0.805, 0.665, 0.945, 0.813, 0.673,
+     0.941, 0.822, 0.681, 0.937, 0.830, 0.689, 0.933, 0.839, 0.697, 0.930,
+     0.848, 0.704, 0.926, 0.856, 0.712, 0.923, 0.865, 0.719, 0.919, 0.873,
+     0.726, 0.916, 0.882, 0.733, 0.912, 0.890, 0.740, 0.908, 0.898, 0.746,
+     0.905, 0.906, 0.752, 0.901, 0.914, 0.757, 0.896, 0.922, 0.762, 0.892,
+     0.929, 0.767, 0.887, 0.937, 0.771, 0.881, 0.943, 0.774, 0.875, 0.950,
+     0.777, 0.868, 0.956, 0.779, 0.860, 0.961, 0.780, 0.851, 0.966, 0.780,
+     0.842, 0.971, 0.780, 0.831, 0.975, 0.779, 0.819, 0.978, 0.777, 0.806,
+     0.980, 0.774, 0.791, 0.982, 0.771, 0.776, 0.983, 0.767, 0.760, 0.984,
+     0.762, 0.742, 0.983, 0.757, 0.725, 0.983, 0.752, 0.706, 0.981, 0.746,
+     0.687, 0.979, 0.740, 0.667, 0.977, 0.733, 0.647, 0.974, 0.727, 0.627,
+     0.971, 0.720, 0.606, 0.968, 0.713, 0.585, 0.964, 0.706, 0.564, 0.960,
+     0.698, 0.543, 0.956, 0.691, 0.522, 0.952, 0.683, 0.501, 0.947, 0.676,
+     0.479, 0.943, 0.668, 0.458, 0.938, 0.660, 0.436, 0.933, 0.652, 0.414,
+     0.928, 0.644, 0.392, 0.923, 0.636, 0.370, 0.918, 0.629, 0.348, 0.913,
+     0.621, 0.326, 0.908, 0.613, 0.303, 0.903, 0.605, 0.280, 0.897, 0.597,
+     0.257, 0.892, 0.589, 0.232, 0.887, 0.581, 0.207, 0.881, 0.573, 0.180,
+     0.727, 0.568, 0.994, 0.735, 0.577, 0.988, 0.743, 0.586, 0.982, 0.751,
+     0.595, 0.977, 0.759, 0.604, 0.971, 0.767, 0.613, 0.966, 0.776, 0.622,
+     0.961, 0.784, 0.630, 0.956, 0.792, 0.639, 0.951, 0.801, 0.647, 0.947,
+     0.809, 0.655, 0.943, 0.817, 0.663, 0.938, 0.826, 0.671, 0.934, 0.834,
+     0.679, 0.930, 0.843, 0.687, 0.927, 0.851, 0.694, 0.923, 0.859, 0.702,
+     0.919, 0.868, 0.709, 0.915, 0.876, 0.715, 0.911, 0.884, 0.722, 0.907,
+     0.892, 0.728, 0.903, 0.900, 0.734, 0.899, 0.908, 0.740, 0.895, 0.916,
+     0.745, 0.890, 0.923, 0.750, 0.885, 0.930, 0.754, 0.879, 0.937, 0.758,
+     0.873, 0.944, 0.761, 0.867, 0.950, 0.763, 0.859, 0.956, 0.765, 0.851,
+     0.961, 0.766, 0.842, 0.966, 0.766, 0.832, 0.970, 0.766, 0.821, 0.974,
+     0.764, 0.809, 0.977, 0.762, 0.796, 0.980, 0.760, 0.782, 0.982, 0.757,
+     0.767, 0.983, 0.753, 0.751, 0.984, 0.749, 0.734, 0.984, 0.744, 0.716,
+     0.983, 0.739, 0.698, 0.982, 0.733, 0.679, 0.980, 0.727, 0.660, 0.978,
+     0.721, 0.640, 0.976, 0.715, 0.620, 0.973, 0.708, 0.600, 0.970, 0.701,
+     0.579, 0.967, 0.694, 0.559, 0.963, 0.687, 0.538, 0.959, 0.680, 0.517,
+     0.955, 0.673, 0.496, 0.951, 0.665, 0.474, 0.946, 0.658, 0.453, 0.942,
+     0.650, 0.432, 0.937, 0.643, 0.410, 0.932, 0.635, 0.388, 0.927, 0.627,
+     0.367, 0.922, 0.619, 0.345, 0.917, 0.612, 0.322, 0.912, 0.604, 0.300,
+     0.907, 0.596, 0.277, 0.902, 0.588, 0.253, 0.897, 0.580, 0.229, 0.891,
+     0.572, 0.204, 0.886, 0.564, 0.177, 0.733, 0.559, 0.993, 0.741, 0.568,
+     0.987, 0.749, 0.577, 0.981, 0.757, 0.587, 0.975, 0.765, 0.595, 0.970,
+     0.773, 0.604, 0.964, 0.781, 0.613, 0.959, 0.789, 0.621, 0.954, 0.797,
+     0.630, 0.949, 0.805, 0.638, 0.945, 0.813, 0.646, 0.940, 0.821, 0.654,
+     0.936, 0.830, 0.662, 0.931, 0.838, 0.669, 0.927, 0.846, 0.677, 0.923,
+     0.854, 0.684, 0.919, 0.862, 0.691, 0.915, 0.870, 0.698, 0.911, 0.879,
+     0.704, 0.907, 0.886, 0.711, 0.902, 0.894, 0.717, 0.898, 0.902, 0.722,
+     0.893, 0.910, 0.727, 0.889, 0.917, 0.732, 0.883, 0.924, 0.737, 0.878,
+     0.931, 0.741, 0.872, 0.938, 0.744, 0.866, 0.944, 0.747, 0.859, 0.950,
+     0.749, 0.851, 0.956, 0.751, 0.842, 0.961, 0.751, 0.833, 0.966, 0.752,
+     0.823, 0.970, 0.751, 0.812, 0.974, 0.750, 0.800, 0.977, 0.748, 0.787,
+     0.979, 0.746, 0.773, 0.981, 0.743, 0.758, 0.983, 0.739, 0.742, 0.984,
+     0.735, 0.725, 0.984, 0.731, 0.708, 0.983, 0.726, 0.690, 0.983, 0.721,
+     0.672, 0.981, 0.715, 0.653, 0.980, 0.709, 0.633, 0.977, 0.703, 0.614,
+     0.975, 0.697, 0.594, 0.972, 0.690, 0.573, 0.969, 0.683, 0.553, 0.965,
+     0.676, 0.532, 0.962, 0.669, 0.512, 0.958, 0.662, 0.491, 0.954, 0.655,
+     0.470, 0.949, 0.648, 0.448, 0.945, 0.640, 0.427, 0.941, 0.633, 0.406,
+     0.936, 0.625, 0.384, 0.931, 0.618, 0.363, 0.926, 0.610, 0.341, 0.921,
+     0.602, 0.319, 0.916, 0.595, 0.296, 0.911, 0.587, 0.273, 0.906, 0.579,
+     0.250, 0.901, 0.571, 0.226, 0.896, 0.563, 0.201, 0.890, 0.556, 0.174,
+     0.739, 0.550, 0.992, 0.747, 0.559, 0.986, 0.754, 0.568, 0.980, 0.762,
+     0.577, 0.974, 0.770, 0.586, 0.968, 0.778, 0.595, 0.962, 0.785, 0.603,
+     0.957, 0.793, 0.612, 0.952, 0.801, 0.620, 0.947, 0.809, 0.628, 0.942,
+     0.817, 0.636, 0.937, 0.825, 0.644, 0.933, 0.833, 0.651, 0.928, 0.841,
+     0.659, 0.924, 0.849, 0.666, 0.919, 0.857, 0.673, 0.915, 0.865, 0.680,
+     0.911, 0.873, 0.686, 0.906, 0.881, 0.693, 0.902, 0.889, 0.699, 0.897,
+     0.896, 0.705, 0.892, 0.904, 0.710, 0.887, 0.911, 0.715, 0.882, 0.918,
+     0.720, 0.877, 0.925, 0.724, 0.871, 0.932, 0.727, 0.865, 0.938, 0.730,
+     0.858, 0.944, 0.733, 0.850, 0.950, 0.735, 0.842, 0.956, 0.736, 0.834,
+     0.961, 0.737, 0.824, 0.965, 0.737, 0.814, 0.970, 0.737, 0.802, 0.973,
+     0.736, 0.790, 0.976, 0.734, 0.777, 0.979, 0.732, 0.763, 0.981, 0.729,
+     0.749, 0.982, 0.726, 0.733, 0.983, 0.722, 0.717, 0.984, 0.717, 0.700,
+     0.984, 0.713, 0.682, 0.983, 0.708, 0.664, 0.982, 0.702, 0.645, 0.980,
+     0.697, 0.626, 0.979, 0.691, 0.607, 0.976, 0.685, 0.587, 0.974, 0.678,
+     0.567, 0.971, 0.672, 0.547, 0.967, 0.665, 0.527, 0.964, 0.658, 0.506,
+     0.960, 0.651, 0.485, 0.956, 0.644, 0.465, 0.952, 0.637, 0.444, 0.948,
+     0.630, 0.423, 0.944, 0.623, 0.401, 0.939, 0.615, 0.380, 0.934, 0.608,
+     0.358, 0.930, 0.600, 0.337, 0.925, 0.593, 0.315, 0.920, 0.585, 0.292,
+     0.915, 0.578, 0.270, 0.910, 0.570, 0.246, 0.905, 0.562, 0.222, 0.899,
+     0.555, 0.197, 0.894, 0.547, 0.171, 0.745, 0.540, 0.991, 0.752, 0.550,
+     0.984, 0.760, 0.559, 0.978, 0.767, 0.568, 0.972, 0.775, 0.577, 0.966,
+     0.782, 0.585, 0.960, 0.790, 0.594, 0.955, 0.798, 0.602, 0.950, 0.806,
+     0.610, 0.944, 0.813, 0.618, 0.939, 0.821, 0.626, 0.934, 0.829, 0.634,
+     0.930, 0.837, 0.641, 0.925, 0.845, 0.648, 0.920, 0.852, 0.655, 0.915,
+     0.860, 0.662, 0.911, 0.868, 0.669, 0.906, 0.876, 0.675, 0.901, 0.883,
+     0.681, 0.897, 0.891, 0.687, 0.892, 0.898, 0.692, 0.887, 0.905, 0.697,
+     0.881, 0.912, 0.702, 0.876, 0.919, 0.707, 0.870, 0.926, 0.710, 0.864,
+     0.932, 0.714, 0.857, 0.939, 0.717, 0.850, 0.945, 0.719, 0.842, 0.950,
+     0.721, 0.834, 0.956, 0.722, 0.825, 0.961, 0.723, 0.815, 0.965, 0.723,
+     0.804, 0.969, 0.723, 0.793, 0.973, 0.722, 0.781, 0.976, 0.720, 0.768,
+     0.978, 0.718, 0.754, 0.981, 0.715, 0.739, 0.982, 0.712, 0.724, 0.983,
+     0.708, 0.708, 0.984, 0.704, 0.691, 0.984, 0.700, 0.674, 0.983, 0.695,
+     0.656, 0.982, 0.690, 0.638, 0.981, 0.684, 0.619, 0.979, 0.679, 0.600,
+     0.977, 0.673, 0.581, 0.975, 0.666, 0.561, 0.972, 0.660, 0.541, 0.969,
+     0.654, 0.521, 0.966, 0.647, 0.501, 0.962, 0.640, 0.480, 0.959, 0.634,
+     0.459, 0.955, 0.627, 0.439, 0.951, 0.620, 0.418, 0.946, 0.612, 0.397,
+     0.942, 0.605, 0.376, 0.937, 0.598, 0.354, 0.933, 0.591, 0.333, 0.928,
+     0.583, 0.311, 0.923, 0.576, 0.289, 0.918, 0.568, 0.266, 0.913, 0.561,
+     0.243, 0.908, 0.553, 0.219, 0.903, 0.546, 0.194, 0.898, 0.538, 0.167,
+     0.750, 0.531, 0.989, 0.757, 0.540, 0.983, 0.765, 0.549, 0.976, 0.772,
+     0.558, 0.970, 0.779, 0.567, 0.964, 0.787, 0.575, 0.958, 0.794, 0.584,
+     0.953, 0.802, 0.592, 0.947, 0.810, 0.600, 0.942, 0.817, 0.608, 0.936,
+     0.825, 0.615, 0.931, 0.833, 0.623, 0.926, 0.840, 0.630, 0.921, 0.848,
+     0.637, 0.916, 0.855, 0.644, 0.911, 0.863, 0.651, 0.907, 0.870, 0.657,
+     0.902, 0.878, 0.663, 0.897, 0.885, 0.669, 0.891, 0.893, 0.675, 0.886,
+     0.900, 0.680, 0.881, 0.907, 0.685, 0.875, 0.914, 0.689, 0.869, 0.920,
+     0.693, 0.863, 0.927, 0.697, 0.857, 0.933, 0.700, 0.850, 0.939, 0.703,
+     0.842, 0.945, 0.705, 0.834, 0.950, 0.707, 0.825, 0.956, 0.708, 0.816,
+     0.960, 0.709, 0.806, 0.965, 0.709, 0.795, 0.969, 0.708, 0.784, 0.972,
+     0.707, 0.772, 0.975, 0.706, 0.759, 0.978, 0.704, 0.745, 0.980, 0.701,
+     0.731, 0.982, 0.698, 0.715, 0.983, 0.694, 0.699, 0.984, 0.691, 0.683,
+     0.984, 0.686, 0.666, 0.983, 0.682, 0.648, 0.983, 0.677, 0.630, 0.982,
+     0.672, 0.612, 0.980, 0.666, 0.593, 0.978, 0.660, 0.574, 0.976, 0.655,
+     0.554, 0.973, 0.648, 0.535, 0.971, 0.642, 0.515, 0.967, 0.636, 0.495,
+     0.964, 0.629, 0.475, 0.961, 0.623, 0.454, 0.957, 0.616, 0.434, 0.953,
+     0.609, 0.413, 0.949, 0.602, 0.392, 0.944, 0.595, 0.371, 0.940, 0.588,
+     0.350, 0.936, 0.580, 0.328, 0.931, 0.573, 0.307, 0.926, 0.566, 0.285,
+     0.921, 0.559, 0.262, 0.916, 0.551, 0.239, 0.911, 0.544, 0.215, 0.906,
+     0.536, 0.190, 0.901, 0.529, 0.164, 0.755, 0.521, 0.988, 0.762, 0.530,
+     0.981, 0.770, 0.539, 0.975, 0.777, 0.548, 0.968, 0.784, 0.557, 0.962,
+     0.791, 0.565, 0.956, 0.799, 0.573, 0.950, 0.806, 0.582, 0.944, 0.814,
+     0.589, 0.939, 0.821, 0.597, 0.933, 0.828, 0.605, 0.928, 0.836, 0.612,
+     0.923, 0.843, 0.619, 0.918, 0.851, 0.626, 0.912, 0.858, 0.633, 0.907,
+     0.866, 0.639, 0.902, 0.873, 0.645, 0.897, 0.880, 0.651, 0.892, 0.887,
+     0.657, 0.886, 0.894, 0.662, 0.881, 0.901, 0.667, 0.875, 0.908, 0.672,
+     0.869, 0.915, 0.676, 0.863, 0.921, 0.680, 0.856, 0.928, 0.684, 0.849,
+     0.934, 0.687, 0.842, 0.940, 0.689, 0.834, 0.945, 0.691, 0.826, 0.951,
+     0.693, 0.817, 0.956, 0.694, 0.807, 0.960, 0.695, 0.797, 0.964, 0.695,
+     0.787, 0.968, 0.694, 0.775, 0.972, 0.693, 0.763, 0.975, 0.692, 0.750,
+     0.977, 0.690, 0.736, 0.980, 0.687, 0.722, 0.981, 0.684, 0.707, 0.982,
+     0.681, 0.691, 0.983, 0.677, 0.675, 0.984, 0.673, 0.658, 0.983, 0.669,
+     0.641, 0.983, 0.664, 0.623, 0.982, 0.659, 0.605, 0.980, 0.654, 0.586,
+     0.979, 0.648, 0.567, 0.977, 0.642, 0.548, 0.974, 0.637, 0.529, 0.972,
+     0.630, 0.509, 0.969, 0.624, 0.489, 0.966, 0.618, 0.469, 0.962, 0.611,
+     0.449, 0.959, 0.605, 0.429, 0.955, 0.598, 0.408, 0.951, 0.591, 0.387,
+     0.947, 0.584, 0.367, 0.942, 0.577, 0.346, 0.938, 0.570, 0.324, 0.933,
+     0.563, 0.303, 0.929, 0.556, 0.281, 0.924, 0.549, 0.258, 0.919, 0.541,
+     0.235, 0.914, 0.534, 0.212, 0.909, 0.527, 0.187, 0.904, 0.519, 0.160,
+     0.760, 0.510, 0.986, 0.767, 0.520, 0.979, 0.774, 0.529, 0.973, 0.781,
+     0.538, 0.966, 0.788, 0.546, 0.960, 0.796, 0.555, 0.954, 0.803, 0.563,
+     0.948, 0.810, 0.571, 0.942, 0.817, 0.579, 0.936, 0.825, 0.586, 0.930,
+     0.832, 0.594, 0.925, 0.839, 0.601, 0.919, 0.846, 0.608, 0.914, 0.854,
+     0.615, 0.908, 0.861, 0.621, 0.903, 0.868, 0.627, 0.897, 0.875, 0.633,
+     0.892, 0.882, 0.639, 0.886, 0.889, 0.645, 0.881, 0.896, 0.650, 0.875,
+     0.903, 0.655, 0.869, 0.909, 0.659, 0.863, 0.916, 0.663, 0.856, 0.922,
+     0.667, 0.849, 0.928, 0.670, 0.842, 0.934, 0.673, 0.834, 0.940, 0.675,
+     0.826, 0.945, 0.677, 0.818, 0.951, 0.679, 0.809, 0.955, 0.680, 0.799,
+     0.960, 0.680, 0.789, 0.964, 0.680, 0.778, 0.968, 0.680, 0.766, 0.971,
+     0.679, 0.754, 0.974, 0.677, 0.741, 0.977, 0.676, 0.727, 0.979, 0.673,
+     0.713, 0.981, 0.670, 0.698, 0.982, 0.667, 0.682, 0.983, 0.664, 0.666,
+     0.983, 0.660, 0.650, 0.983, 0.655, 0.633, 0.983, 0.651, 0.615, 0.982,
+     0.646, 0.597, 0.981, 0.641, 0.579, 0.979, 0.636, 0.560, 0.977, 0.630,
+     0.541, 0.975, 0.625, 0.522, 0.973, 0.619, 0.503, 0.970, 0.613, 0.483,
+     0.967, 0.606, 0.463, 0.964, 0.600, 0.443, 0.960, 0.594, 0.423, 0.956,
+     0.587, 0.403, 0.953, 0.580, 0.383, 0.949, 0.574, 0.362, 0.944, 0.567,
+     0.341, 0.940, 0.560, 0.320, 0.936, 0.553, 0.298, 0.931, 0.546, 0.277,
+     0.926, 0.539, 0.254, 0.922, 0.532, 0.232, 0.917, 0.524, 0.208, 0.912,
+     0.517, 0.183, 0.906, 0.510, 0.156, 0.765, 0.499, 0.985, 0.772, 0.509,
+     0.978, 0.779, 0.518, 0.971, 0.786, 0.527, 0.964, 0.793, 0.535, 0.957,
+     0.800, 0.544, 0.951, 0.807, 0.552, 0.945, 0.814, 0.560, 0.939, 0.821,
+     0.568, 0.933, 0.828, 0.575, 0.927, 0.835, 0.582, 0.921, 0.842, 0.589,
+     0.915, 0.849, 0.596, 0.910, 0.856, 0.603, 0.904, 0.863, 0.609, 0.898,
+     0.870, 0.615, 0.893, 0.877, 0.621, 0.887, 0.884, 0.627, 0.881, 0.891,
+     0.632, 0.875, 0.898, 0.637, 0.869, 0.904, 0.642, 0.863, 0.911, 0.646,
+     0.856, 0.917, 0.650, 0.849, 0.923, 0.653, 0.842, 0.929, 0.657, 0.835,
+     0.935, 0.659, 0.827, 0.940, 0.662, 0.818, 0.946, 0.663, 0.810, 0.951,
+     0.665, 0.800, 0.955, 0.666, 0.790, 0.960, 0.666, 0.780, 0.964, 0.666,
+     0.769, 0.967, 0.666, 0.757, 0.971, 0.665, 0.745, 0.974, 0.663, 0.732,
+     0.976, 0.662, 0.718, 0.978, 0.659, 0.704, 0.980, 0.657, 0.689, 0.981,
+     0.654, 0.674, 0.982, 0.650, 0.658, 0.983, 0.646, 0.642, 0.983, 0.642,
+     0.625, 0.983, 0.638, 0.608, 0.982, 0.633, 0.590, 0.981, 0.628, 0.572,
+     0.979, 0.623, 0.553, 0.978, 0.618, 0.535, 0.976, 0.612, 0.516, 0.973,
+     0.607, 0.497, 0.971, 0.601, 0.477, 0.968, 0.595, 0.458, 0.965, 0.589,
+     0.438, 0.961, 0.582, 0.418, 0.958, 0.576, 0.398, 0.954, 0.569, 0.378,
+     0.950, 0.563, 0.357, 0.946, 0.556, 0.336, 0.942, 0.549, 0.315, 0.938,
+     0.542, 0.294, 0.933, 0.536, 0.273, 0.928, 0.529, 0.250, 0.924, 0.522,
+     0.228, 0.919, 0.514, 0.204, 0.914, 0.507, 0.179, 0.909, 0.500, 0.153,
+     0.770, 0.488, 0.983, 0.777, 0.498, 0.976, 0.783, 0.507, 0.969, 0.790,
+     0.516, 0.962, 0.797, 0.524, 0.955, 0.804, 0.533, 0.948, 0.811, 0.541,
+     0.942, 0.817, 0.549, 0.936, 0.824, 0.556, 0.930, 0.831, 0.564, 0.924,
+     0.838, 0.571, 0.918, 0.845, 0.578, 0.912, 0.852, 0.584, 0.906, 0.859,
+     0.591, 0.900, 0.866, 0.597, 0.894, 0.873, 0.603, 0.888, 0.879, 0.609,
+     0.882, 0.886, 0.614, 0.876, 0.893, 0.619, 0.869, 0.899, 0.624, 0.863,
+     0.906, 0.629, 0.856, 0.912, 0.633, 0.850, 0.918, 0.637, 0.843, 0.924,
+     0.640, 0.835, 0.930, 0.643, 0.827, 0.935, 0.646, 0.819, 0.941, 0.648,
+     0.811, 0.946, 0.649, 0.802, 0.951, 0.651, 0.792, 0.955, 0.652, 0.782,
+     0.959, 0.652, 0.771, 0.963, 0.652, 0.760, 0.967, 0.652, 0.749, 0.970,
+     0.651, 0.736, 0.973, 0.649, 0.723, 0.976, 0.647, 0.710, 0.978, 0.645,
+     0.696, 0.980, 0.643, 0.681, 0.981, 0.640, 0.666, 0.982, 0.637, 0.650,
+     0.982, 0.633, 0.634, 0.983, 0.629, 0.617, 0.982, 0.625, 0.600, 0.982,
+     0.620, 0.582, 0.981, 0.616, 0.565, 0.979, 0.611, 0.546, 0.978, 0.605,
+     0.528, 0.976, 0.600, 0.509, 0.974, 0.595, 0.490, 0.971, 0.589, 0.471,
+     0.969, 0.583, 0.452, 0.966, 0.577, 0.432, 0.962, 0.571, 0.413, 0.959,
+     0.565, 0.393, 0.955, 0.558, 0.373, 0.952, 0.552, 0.352, 0.948, 0.545,
+     0.332, 0.943, 0.539, 0.311, 0.939, 0.532, 0.290, 0.935, 0.525, 0.268,
+     0.930, 0.518, 0.246, 0.926, 0.511, 0.224, 0.921, 0.504, 0.200, 0.916,
+     0.497, 0.175, 0.911, 0.490, 0.149, 0.775, 0.477, 0.981, 0.781, 0.486,
+     0.974, 0.788, 0.495, 0.966, 0.794, 0.504, 0.959, 0.801, 0.513, 0.952,
+     0.808, 0.521, 0.946, 0.814, 0.529, 0.939, 0.821, 0.537, 0.933, 0.828,
+     0.545, 0.926, 0.835, 0.552, 0.920, 0.841, 0.559, 0.914, 0.848, 0.566,
+     0.908, 0.855, 0.572, 0.901, 0.862, 0.579, 0.895, 0.868, 0.585, 0.889,
+     0.875, 0.591, 0.883, 0.881, 0.596, 0.877, 0.888, 0.601, 0.870, 0.894,
+     0.606, 0.864, 0.901, 0.611, 0.857, 0.907, 0.615, 0.850, 0.913, 0.619,
+     0.843, 0.919, 0.623, 0.836, 0.925, 0.626, 0.828, 0.930, 0.629, 0.820,
+     0.936, 0.632, 0.812, 0.941, 0.634, 0.803, 0.946, 0.635, 0.794, 0.951,
+     0.637, 0.784, 0.955, 0.637, 0.774, 0.959, 0.638, 0.763, 0.963, 0.638,
+     0.752, 0.967, 0.637, 0.740, 0.970, 0.636, 0.728, 0.973, 0.635, 0.715,
+     0.975, 0.633, 0.701, 0.977, 0.631, 0.687, 0.979, 0.629, 0.672, 0.980,
+     0.626, 0.657, 0.981, 0.623, 0.642, 0.982, 0.619, 0.626, 0.982, 0.616,
+     0.609, 0.982, 0.612, 0.592, 0.981, 0.607, 0.575, 0.981, 0.603, 0.557,
+     0.979, 0.598, 0.540, 0.978, 0.593, 0.521, 0.976, 0.588, 0.503, 0.974,
+     0.582, 0.484, 0.972, 0.577, 0.465, 0.969, 0.571, 0.446, 0.966, 0.565,
+     0.427, 0.963, 0.559, 0.407, 0.960, 0.553, 0.387, 0.956, 0.547, 0.368,
+     0.953, 0.541, 0.347, 0.949, 0.534, 0.327, 0.945, 0.528, 0.306, 0.941,
+     0.521, 0.285, 0.936, 0.514, 0.264, 0.932, 0.508, 0.242, 0.927, 0.501,
+     0.220, 0.922, 0.494, 0.196, 0.918, 0.487, 0.172, 0.913, 0.480, 0.145,
+     0.779, 0.465, 0.979, 0.785, 0.474, 0.971, 0.792, 0.484, 0.964, 0.798,
+     0.492, 0.957, 0.805, 0.501, 0.950, 0.811, 0.509, 0.943, 0.818, 0.517,
+     0.936, 0.824, 0.525, 0.929, 0.831, 0.533, 0.923, 0.838, 0.540, 0.916,
+     0.844, 0.547, 0.910, 0.851, 0.554, 0.904, 0.857, 0.560, 0.897, 0.864,
+     0.566, 0.891, 0.870, 0.572, 0.884, 0.877, 0.578, 0.878, 0.883, 0.583,
+     0.871, 0.890, 0.589, 0.865, 0.896, 0.593, 0.858, 0.902, 0.598, 0.851,
+     0.908, 0.602, 0.844, 0.914, 0.606, 0.837, 0.920, 0.609, 0.829, 0.925,
+     0.613, 0.821, 0.931, 0.615, 0.813, 0.936, 0.618, 0.804, 0.941, 0.620,
+     0.795, 0.946, 0.621, 0.786, 0.950, 0.622, 0.776, 0.955, 0.623, 0.765,
+     0.959, 0.624, 0.755, 0.963, 0.624, 0.743, 0.966, 0.623, 0.731, 0.969,
+     0.622, 0.719, 0.972, 0.621, 0.706, 0.974, 0.619, 0.693, 0.976, 0.617,
+     0.679, 0.978, 0.615, 0.664, 0.979, 0.612, 0.649, 0.980, 0.609, 0.634,
+     0.981, 0.606, 0.618, 0.981, 0.602, 0.601, 0.981, 0.598, 0.585, 0.981,
+     0.594, 0.568, 0.980, 0.590, 0.550, 0.979, 0.585, 0.533, 0.978, 0.580,
+     0.515, 0.976, 0.575, 0.496, 0.974, 0.570, 0.478, 0.972, 0.565, 0.459,
+     0.969, 0.559, 0.440, 0.967, 0.553, 0.421, 0.964, 0.547, 0.402, 0.960,
+     0.542, 0.382, 0.957, 0.535, 0.362, 0.953, 0.529, 0.342, 0.950, 0.523,
+     0.322, 0.946, 0.517, 0.302, 0.942, 0.510, 0.281, 0.937, 0.504, 0.260,
+     0.933, 0.497, 0.238, 0.929, 0.490, 0.216, 0.924, 0.484, 0.192, 0.919,
+     0.477, 0.168, 0.914, 0.470, 0.141, 0.783, 0.453, 0.977, 0.789, 0.462,
+     0.969, 0.796, 0.471, 0.962, 0.802, 0.480, 0.954, 0.808, 0.489, 0.947,
+     0.815, 0.497, 0.940, 0.821, 0.505, 0.933, 0.828, 0.513, 0.926, 0.834,
+     0.520, 0.919, 0.840, 0.527, 0.913, 0.847, 0.534, 0.906, 0.853, 0.541,
+     0.899, 0.860, 0.548, 0.893, 0.866, 0.554, 0.886, 0.873, 0.560, 0.880,
+     0.879, 0.565, 0.873, 0.885, 0.570, 0.866, 0.891, 0.575, 0.859, 0.897,
+     0.580, 0.852, 0.903, 0.585, 0.845, 0.909, 0.589, 0.838, 0.915, 0.592,
+     0.830, 0.921, 0.596, 0.822, 0.926, 0.599, 0.814, 0.931, 0.601, 0.805,
+     0.936, 0.604, 0.797, 0.941, 0.606, 0.787, 0.946, 0.607, 0.778, 0.950,
+     0.608, 0.768, 0.955, 0.609, 0.757, 0.958, 0.609, 0.746, 0.962, 0.609,
+     0.735, 0.965, 0.609, 0.723, 0.968, 0.608, 0.710, 0.971, 0.607, 0.698,
+     0.974, 0.605, 0.684, 0.976, 0.603, 0.670, 0.977, 0.601, 0.656, 0.979,
+     0.598, 0.641, 0.980, 0.596, 0.626, 0.980, 0.592, 0.610, 0.981, 0.589,
+     0.594, 0.981, 0.585, 0.577, 0.980, 0.581, 0.560, 0.980, 0.577, 0.543,
+     0.979, 0.572, 0.526, 0.977, 0.568, 0.508, 0.976, 0.563, 0.490, 0.974,
+     0.558, 0.471, 0.972, 0.552, 0.453, 0.969, 0.547, 0.434, 0.967, 0.541,
+     0.415, 0.964, 0.536, 0.396, 0.961, 0.530, 0.377, 0.958, 0.524, 0.357,
+     0.954, 0.518, 0.337, 0.950, 0.512, 0.317, 0.947, 0.505, 0.297, 0.943,
+     0.499, 0.276, 0.938, 0.493, 0.255, 0.934, 0.486, 0.234, 0.930, 0.480,
+     0.211, 0.925, 0.473, 0.188, 0.920, 0.466, 0.164, 0.916, 0.459, 0.137,
+     0.787, 0.440, 0.975, 0.793, 0.450, 0.967, 0.799, 0.459, 0.959, 0.806,
+     0.468, 0.952, 0.812, 0.476, 0.944, 0.818, 0.485, 0.937, 0.824, 0.493,
+     0.930, 0.831, 0.500, 0.923, 0.837, 0.508, 0.916, 0.843, 0.515, 0.909,
+     0.850, 0.522, 0.902, 0.856, 0.528, 0.895, 0.862, 0.535, 0.888, 0.868,
+     0.541, 0.881, 0.874, 0.547, 0.875, 0.881, 0.552, 0.868, 0.887, 0.557,
+     0.861, 0.893, 0.562, 0.853, 0.899, 0.567, 0.846, 0.904, 0.571, 0.839,
+     0.910, 0.575, 0.831, 0.916, 0.579, 0.823, 0.921, 0.582, 0.815, 0.926,
+     0.585, 0.807, 0.932, 0.587, 0.798, 0.937, 0.590, 0.789, 0.941, 0.591,
+     0.780, 0.946, 0.593, 0.770, 0.950, 0.594, 0.760, 0.954, 0.595, 0.749,
+     0.958, 0.595, 0.738, 0.962, 0.595, 0.727, 0.965, 0.595, 0.715, 0.968,
+     0.594, 0.702, 0.970, 0.593, 0.689, 0.973, 0.591, 0.676, 0.975, 0.589,
+     0.662, 0.976, 0.587, 0.648, 0.978, 0.585, 0.633, 0.979, 0.582, 0.618,
+     0.980, 0.579, 0.602, 0.980, 0.575, 0.586, 0.980, 0.572, 0.570, 0.980,
+     0.568, 0.553, 0.979, 0.564, 0.536, 0.978, 0.559, 0.518, 0.977, 0.555,
+     0.501, 0.975, 0.550, 0.483, 0.974, 0.545, 0.465, 0.972, 0.540, 0.447,
+     0.969, 0.535, 0.428, 0.967, 0.529, 0.409, 0.964, 0.524, 0.390, 0.961,
+     0.518, 0.371, 0.958, 0.512, 0.352, 0.954, 0.506, 0.332, 0.951, 0.500,
+     0.312, 0.947, 0.494, 0.292, 0.943, 0.488, 0.272, 0.939, 0.481, 0.251,
+     0.935, 0.475, 0.229, 0.931, 0.469, 0.207, 0.926, 0.462, 0.184, 0.921,
+     0.455, 0.159, 0.917, 0.449, 0.133, 0.791, 0.427, 0.973, 0.797, 0.437,
+     0.964, 0.803, 0.446, 0.957, 0.809, 0.455, 0.949, 0.815, 0.464, 0.941,
+     0.821, 0.472, 0.934, 0.827, 0.480, 0.926, 0.834, 0.488, 0.919, 0.840,
+     0.495, 0.912, 0.846, 0.502, 0.905, 0.852, 0.509, 0.898, 0.858, 0.515,
+     0.891, 0.864, 0.522, 0.884, 0.870, 0.528, 0.877, 0.876, 0.533, 0.870,
+     0.882, 0.539, 0.862, 0.888, 0.544, 0.855, 0.894, 0.549, 0.848, 0.900,
+     0.553, 0.840, 0.906, 0.557, 0.833, 0.911, 0.561, 0.825, 0.916, 0.565,
+     0.817, 0.922, 0.568, 0.808, 0.927, 0.571, 0.800, 0.932, 0.573, 0.791,
+     0.937, 0.575, 0.782, 0.941, 0.577, 0.772, 0.946, 0.579, 0.762, 0.950,
+     0.580, 0.752, 0.954, 0.580, 0.741, 0.958, 0.581, 0.730, 0.961, 0.581,
+     0.718, 0.964, 0.580, 0.706, 0.967, 0.580, 0.694, 0.970, 0.578, 0.681,
+     0.972, 0.577, 0.667, 0.974, 0.575, 0.654, 0.976, 0.573, 0.639, 0.977,
+     0.571, 0.625, 0.978, 0.568, 0.610, 0.979, 0.565, 0.594, 0.979, 0.562,
+     0.578, 0.979, 0.558, 0.562, 0.979, 0.554, 0.545, 0.978, 0.550, 0.529,
+     0.977, 0.546, 0.511, 0.976, 0.542, 0.494, 0.975, 0.537, 0.476, 0.973,
+     0.532, 0.458, 0.971, 0.527, 0.440, 0.969, 0.522, 0.422, 0.967, 0.517,
+     0.403, 0.964, 0.511, 0.385, 0.961, 0.506, 0.366, 0.958, 0.500, 0.347,
+     0.955, 0.494, 0.327, 0.951, 0.488, 0.307, 0.947, 0.482, 0.287, 0.944,
+     0.476, 0.267, 0.940, 0.470, 0.246, 0.935, 0.464, 0.225, 0.931, 0.458,
+     0.203, 0.927, 0.451, 0.180, 0.922, 0.445, 0.155, 0.917, 0.438, 0.129,
+     0.795, 0.413, 0.970, 0.801, 0.423, 0.962, 0.807, 0.433, 0.954, 0.813,
+     0.442, 0.946, 0.818, 0.450, 0.938, 0.824, 0.459, 0.930, 0.830, 0.467,
+     0.923, 0.836, 0.474, 0.915, 0.842, 0.482, 0.908, 0.848, 0.489, 0.901,
+     0.854, 0.496, 0.894, 0.860, 0.502, 0.886, 0.866, 0.508, 0.879, 0.872,
+     0.514, 0.872, 0.878, 0.520, 0.864, 0.884, 0.525, 0.857, 0.890, 0.530,
+     0.850, 0.895, 0.535, 0.842, 0.901, 0.539, 0.834, 0.906, 0.543, 0.826,
+     0.912, 0.547, 0.818, 0.917, 0.551, 0.810, 0.922, 0.554, 0.801, 0.927,
+     0.557, 0.793, 0.932, 0.559, 0.783, 0.937, 0.561, 0.774, 0.941, 0.563,
+     0.764, 0.946, 0.564, 0.754, 0.950, 0.565, 0.744, 0.953, 0.566, 0.733,
+     0.957, 0.566, 0.722, 0.960, 0.566, 0.710, 0.963, 0.566, 0.698, 0.966,
+     0.565, 0.685, 0.969, 0.564, 0.673, 0.971, 0.563, 0.659, 0.973, 0.561,
+     0.645, 0.975, 0.559, 0.631, 0.976, 0.557, 0.617, 0.977, 0.554, 0.602,
+     0.978, 0.551, 0.586, 0.978, 0.548, 0.571, 0.978, 0.545, 0.554, 0.978,
+     0.541, 0.538, 0.977, 0.537, 0.521, 0.977, 0.533, 0.504, 0.976, 0.529,
+     0.487, 0.974, 0.524, 0.470, 0.973, 0.519, 0.452, 0.971, 0.515, 0.434,
+     0.969, 0.510, 0.416, 0.966, 0.504, 0.398, 0.964, 0.499, 0.379, 0.961,
+     0.494, 0.360, 0.958, 0.488, 0.341, 0.955, 0.482, 0.322, 0.951, 0.477,
+     0.302, 0.948, 0.471, 0.283, 0.944, 0.465, 0.262, 0.940, 0.459, 0.242,
+     0.936, 0.452, 0.220, 0.932, 0.446, 0.198, 0.927, 0.440, 0.175, 0.923,
+     0.434, 0.151, 0.918, 0.427, 0.124, 0.799, 0.399, 0.968, 0.804, 0.409,
+     0.959, 0.810, 0.419, 0.951, 0.816, 0.428, 0.943, 0.822, 0.437, 0.935,
+     0.827, 0.445, 0.927, 0.833, 0.453, 0.919, 0.839, 0.461, 0.912, 0.845,
+     0.468, 0.904, 0.851, 0.475, 0.897, 0.857, 0.482, 0.889, 0.862, 0.489,
+     0.882, 0.868, 0.495, 0.874, 0.874, 0.501, 0.867, 0.880, 0.506, 0.859,
+     0.885, 0.511, 0.852, 0.891, 0.516, 0.844, 0.897, 0.521, 0.836, 0.902,
+     0.525, 0.828, 0.907, 0.529, 0.820, 0.913, 0.533, 0.812, 0.918, 0.537,
+     0.803, 0.923, 0.540, 0.794, 0.928, 0.542, 0.785, 0.932, 0.545, 0.776,
+     0.937, 0.547, 0.767, 0.941, 0.549, 0.757, 0.945, 0.550, 0.747, 0.949,
+     0.551, 0.736, 0.953, 0.552, 0.725, 0.956, 0.552, 0.714, 0.960, 0.552,
+     0.702, 0.963, 0.552, 0.690, 0.965, 0.551, 0.677, 0.968, 0.550, 0.664,
+     0.970, 0.549, 0.651, 0.972, 0.547, 0.637, 0.974, 0.545, 0.623, 0.975,
+     0.543, 0.609, 0.976, 0.540, 0.594, 0.977, 0.537, 0.578, 0.977, 0.534,
+     0.563, 0.977, 0.531, 0.547, 0.977, 0.527, 0.531, 0.976, 0.524, 0.514,
+     0.976, 0.520, 0.497, 0.975, 0.516, 0.480, 0.973, 0.511, 0.463, 0.972,
+     0.507, 0.446, 0.970, 0.502, 0.428, 0.968, 0.497, 0.410, 0.966, 0.492,
+     0.392, 0.963, 0.487, 0.373, 0.960, 0.481, 0.355, 0.957, 0.476, 0.336,
+     0.954, 0.470, 0.317, 0.951, 0.465, 0.297, 0.947, 0.459, 0.278, 0.944,
+     0.453, 0.258, 0.940, 0.447, 0.237, 0.936, 0.441, 0.216, 0.932, 0.435,
+     0.194, 0.927, 0.429, 0.171, 0.923, 0.422, 0.147, 0.918, 0.416, 0.120,
+     0.802, 0.385, 0.965, 0.808, 0.395, 0.957, 0.813, 0.405, 0.948, 0.819,
+     0.414, 0.940, 0.825, 0.423, 0.932, 0.830, 0.431, 0.924, 0.836, 0.439,
+     0.916, 0.842, 0.447, 0.908, 0.847, 0.454, 0.900, 0.853, 0.462, 0.892,
+     0.859, 0.468, 0.885, 0.864, 0.475, 0.877, 0.870, 0.481, 0.869, 0.876,
+     0.487, 0.862, 0.881, 0.492, 0.854, 0.887, 0.498, 0.846, 0.892, 0.502,
+     0.838, 0.898, 0.507, 0.830, 0.903, 0.511, 0.822, 0.908, 0.515, 0.814,
+     0.913, 0.519, 0.805, 0.918, 0.522, 0.797, 0.923, 0.525, 0.788, 0.928,
+     0.528, 0.778, 0.932, 0.530, 0.769, 0.937, 0.532, 0.759, 0.941, 0.534,
+     0.749, 0.945, 0.535, 0.739, 0.949, 0.536, 0.728, 0.952, 0.537, 0.717,
+     0.956, 0.537, 0.706, 0.959, 0.537, 0.694, 0.962, 0.537, 0.682, 0.964,
+     0.536, 0.669, 0.967, 0.536, 0.656, 0.969, 0.534, 0.643, 0.971, 0.533,
+     0.629, 0.972, 0.531, 0.615, 0.974, 0.529, 0.601, 0.975, 0.526, 0.586,
+     0.975, 0.523, 0.571, 0.976, 0.521, 0.555, 0.976, 0.517, 0.540, 0.976,
+     0.514, 0.523, 0.975, 0.510, 0.507, 0.975, 0.506, 0.490, 0.974, 0.502,
+     0.474, 0.972, 0.498, 0.456, 0.971, 0.494, 0.439, 0.969, 0.489, 0.421,
+     0.967, 0.484, 0.404, 0.965, 0.479, 0.386, 0.963, 0.474, 0.367, 0.960,
+     0.469, 0.349, 0.957, 0.464, 0.330, 0.954, 0.458, 0.311, 0.951, 0.453,
+     0.292, 0.947, 0.447, 0.273, 0.944, 0.441, 0.253, 0.940, 0.435, 0.232,
+     0.936, 0.429, 0.211, 0.932, 0.423, 0.190, 0.927, 0.417, 0.167, 0.923,
+     0.411, 0.142, 0.919, 0.405, 0.116, 0.806, 0.370, 0.963, 0.811, 0.380,
+     0.954, 0.816, 0.390, 0.945, 0.822, 0.399, 0.937, 0.827, 0.408, 0.929,
+     0.833, 0.417, 0.920, 0.838, 0.425, 0.912, 0.844, 0.433, 0.904, 0.850,
+     0.440, 0.896, 0.855, 0.447, 0.888, 0.861, 0.454, 0.880, 0.866, 0.461,
+     0.872, 0.872, 0.467, 0.865, 0.877, 0.473, 0.857, 0.883, 0.478, 0.849,
+     0.888, 0.483, 0.841, 0.893, 0.488, 0.833, 0.899, 0.493, 0.824, 0.904,
+     0.497, 0.816, 0.909, 0.501, 0.807, 0.914, 0.505, 0.799, 0.919, 0.508,
+     0.790, 0.923, 0.511, 0.781, 0.928, 0.514, 0.771, 0.932, 0.516, 0.762,
+     0.937, 0.518, 0.752, 0.941, 0.520, 0.742, 0.945, 0.521, 0.731, 0.948,
+     0.522, 0.720, 0.952, 0.523, 0.709, 0.955, 0.523, 0.698, 0.958, 0.523,
+     0.686, 0.961, 0.523, 0.674, 0.964, 0.522, 0.661, 0.966, 0.521, 0.648,
+     0.968, 0.520, 0.635, 0.970, 0.518, 0.621, 0.971, 0.517, 0.607, 0.972,
+     0.514, 0.593, 0.973, 0.512, 0.578, 0.974, 0.509, 0.563, 0.975, 0.507,
+     0.548, 0.975, 0.503, 0.532, 0.975, 0.500, 0.516, 0.974, 0.497, 0.500,
+     0.974, 0.493, 0.483, 0.973, 0.489, 0.467, 0.971, 0.485, 0.450, 0.970,
+     0.480, 0.433, 0.968, 0.476, 0.415, 0.966, 0.471, 0.397, 0.964, 0.466,
+     0.380, 0.962, 0.461, 0.362, 0.959, 0.456, 0.343, 0.956, 0.451, 0.325,
+     0.953, 0.446, 0.306, 0.950, 0.440, 0.287, 0.947, 0.435, 0.268, 0.943,
+     0.429, 0.248, 0.939, 0.423, 0.228, 0.936, 0.417, 0.207, 0.931, 0.411,
+     0.185, 0.927, 0.405, 0.162, 0.923, 0.399, 0.138, 0.918, 0.393, 0.111,
+     0.809, 0.354, 0.960, 0.814, 0.364, 0.951, 0.819, 0.375, 0.942, 0.825,
+     0.384, 0.934, 0.830, 0.393, 0.925, 0.835, 0.402, 0.917, 0.841, 0.410,
+     0.908, 0.846, 0.418, 0.900, 0.852, 0.426, 0.892, 0.857, 0.433, 0.884,
+     0.863, 0.440, 0.876, 0.868, 0.446, 0.868, 0.873, 0.452, 0.860, 0.879,
+     0.458, 0.852, 0.884, 0.464, 0.843, 0.889, 0.469, 0.835, 0.894, 0.474,
+     0.827, 0.899, 0.478, 0.818, 0.904, 0.483, 0.810, 0.909, 0.486, 0.801,
+     0.914, 0.490, 0.792, 0.919, 0.493, 0.783, 0.923, 0.496, 0.774, 0.928,
+     0.499, 0.764, 0.932, 0.501, 0.755, 0.936, 0.503, 0.745, 0.940, 0.505,
+     0.734, 0.944, 0.506, 0.724, 0.948, 0.507, 0.713, 0.951, 0.508, 0.701,
+     0.954, 0.508, 0.690, 0.957, 0.508, 0.678, 0.960, 0.508, 0.666, 0.962,
+     0.507, 0.653, 0.965, 0.507, 0.640, 0.967, 0.505, 0.627, 0.968, 0.504,
+     0.613, 0.970, 0.502, 0.599, 0.971, 0.500, 0.585, 0.972, 0.498, 0.570,
+     0.973, 0.495, 0.555, 0.973, 0.493, 0.540, 0.973, 0.490, 0.525, 0.973,
+     0.486, 0.509, 0.973, 0.483, 0.493, 0.972, 0.479, 0.476, 0.971, 0.475,
+     0.460, 0.970, 0.471, 0.443, 0.969, 0.467, 0.426, 0.967, 0.463, 0.409,
+     0.965, 0.458, 0.391, 0.963, 0.453, 0.374, 0.961, 0.449, 0.356, 0.958,
+     0.444, 0.338, 0.956, 0.438, 0.319, 0.953, 0.433, 0.301, 0.949, 0.428,
+     0.282, 0.946, 0.422, 0.263, 0.943, 0.417, 0.243, 0.939, 0.411, 0.223,
+     0.935, 0.405, 0.202, 0.931, 0.399, 0.181, 0.927, 0.393, 0.158, 0.923,
+     0.387, 0.134, 0.918, 0.381, 0.107,
+     ]).reshape((65, 65, 3))
+
+BiOrangeBlue = np.array(
+    [0.000, 0.000, 0.000, 0.000, 0.062, 0.125, 0.000, 0.125, 0.250, 0.000,
+     0.188, 0.375, 0.000, 0.250, 0.500, 0.000, 0.312, 0.625, 0.000, 0.375,
+     0.750, 0.000, 0.438, 0.875, 0.000, 0.500, 1.000, 0.125, 0.062, 0.000,
+     0.125, 0.125, 0.125, 0.125, 0.188, 0.250, 0.125, 0.250, 0.375, 0.125,
+     0.312, 0.500, 0.125, 0.375, 0.625, 0.125, 0.438, 0.750, 0.125, 0.500,
+     0.875, 0.125, 0.562, 1.000, 0.250, 0.125, 0.000, 0.250, 0.188, 0.125,
+     0.250, 0.250, 0.250, 0.250, 0.312, 0.375, 0.250, 0.375, 0.500, 0.250,
+     0.438, 0.625, 0.250, 0.500, 0.750, 0.250, 0.562, 0.875, 0.250, 0.625,
+     1.000, 0.375, 0.188, 0.000, 0.375, 0.250, 0.125, 0.375, 0.312, 0.250,
+     0.375, 0.375, 0.375, 0.375, 0.438, 0.500, 0.375, 0.500, 0.625, 0.375,
+     0.562, 0.750, 0.375, 0.625, 0.875, 0.375, 0.688, 1.000, 0.500, 0.250,
+     0.000, 0.500, 0.312, 0.125, 0.500, 0.375, 0.250, 0.500, 0.438, 0.375,
+     0.500, 0.500, 0.500, 0.500, 0.562, 0.625, 0.500, 0.625, 0.750, 0.500,
+     0.688, 0.875, 0.500, 0.750, 1.000, 0.625, 0.312, 0.000, 0.625, 0.375,
+     0.125, 0.625, 0.438, 0.250, 0.625, 0.500, 0.375, 0.625, 0.562, 0.500,
+     0.625, 0.625, 0.625, 0.625, 0.688, 0.750, 0.625, 0.750, 0.875, 0.625,
+     0.812, 1.000, 0.750, 0.375, 0.000, 0.750, 0.438, 0.125, 0.750, 0.500,
+     0.250, 0.750, 0.562, 0.375, 0.750, 0.625, 0.500, 0.750, 0.688, 0.625,
+     0.750, 0.750, 0.750, 0.750, 0.812, 0.875, 0.750, 0.875, 1.000, 0.875,
+     0.438, 0.000, 0.875, 0.500, 0.125, 0.875, 0.562, 0.250, 0.875, 0.625,
+     0.375, 0.875, 0.688, 0.500, 0.875, 0.750, 0.625, 0.875, 0.812, 0.750,
+     0.875, 0.875, 0.875, 0.875, 0.938, 1.000, 1.000, 0.500, 0.000, 1.000,
+     0.562, 0.125, 1.000, 0.625, 0.250, 1.000, 0.688, 0.375, 1.000, 0.750,
+     0.500, 1.000, 0.812, 0.625, 1.000, 0.875, 0.750, 1.000, 0.938, 0.875,
+     1.000, 1.000, 1.000,
+     ]).reshape((9, 9, 3))
+
+cmaps = {
+    "BiPeak": SegmentedBivarColormap(
+        BiPeak, 256, "square", (.5, .5), name="BiPeak"),
+    "BiOrangeBlue": SegmentedBivarColormap(
+        BiOrangeBlue, 256, "square", (0, 0), name="BiOrangeBlue"),
+    "BiCone": SegmentedBivarColormap(BiPeak, 256, "circle", (.5, .5), name="BiCone"),
+}

infer_4_30_0/lib/python3.10/site-packages/matplotlib/_color_data.pyi

@@ -0,0 +1,6 @@
+from .typing import ColorType
+
+BASE_COLORS: dict[str, ColorType]
+TABLEAU_COLORS: dict[str, ColorType]
+XKCD_COLORS: dict[str, ColorType]
+CSS4_COLORS: dict[str, ColorType]

infer_4_30_0/lib/python3.10/site-packages/matplotlib/_constrained_layout.py

@@ -0,0 +1,801 @@
+"""
+Adjust subplot layouts so that there are no overlapping Axes or Axes
+decorations.  All Axes decorations are dealt with (labels, ticks, titles,
+ticklabels) and some dependent artists are also dealt with (colorbar,
+suptitle).
+
+Layout is done via `~matplotlib.gridspec`, with one constraint per gridspec,
+so it is possible to have overlapping Axes if the gridspecs overlap (i.e.
+using `~matplotlib.gridspec.GridSpecFromSubplotSpec`).  Axes placed using
+``figure.subplots()`` or ``figure.add_subplots()`` will participate in the
+layout.  Axes manually placed via ``figure.add_axes()`` will not.
+
+See Tutorial: :ref:`constrainedlayout_guide`
+
+General idea:
+-------------
+
+First, a figure has a gridspec that divides the figure into nrows and ncols,
+with heights and widths set by ``height_ratios`` and ``width_ratios``,
+often just set to 1 for an equal grid.
+
+Subplotspecs that are derived from this gridspec can contain either a
+``SubPanel``, a ``GridSpecFromSubplotSpec``, or an ``Axes``.  The ``SubPanel``
+and ``GridSpecFromSubplotSpec`` are dealt with recursively and each contain an
+analogous layout.
+
+Each ``GridSpec`` has a ``_layoutgrid`` attached to it.  The ``_layoutgrid``
+has the same logical layout as the ``GridSpec``.   Each row of the grid spec
+has a top and bottom "margin" and each column has a left and right "margin".
+The "inner" height of each row is constrained to be the same (or as modified
+by ``height_ratio``), and the "inner" width of each column is
+constrained to be the same (as modified by ``width_ratio``), where "inner"
+is the width or height of each column/row minus the size of the margins.
+
+Then the size of the margins for each row and column are determined as the
+max width of the decorators on each Axes that has decorators in that margin.
+For instance, a normal Axes would have a left margin that includes the
+left ticklabels, and the ylabel if it exists.  The right margin may include a
+colorbar, the bottom margin the xaxis decorations, and the top margin the
+title.
+
+With these constraints, the solver then finds appropriate bounds for the
+columns and rows.  It's possible that the margins take up the whole figure,
+in which case the algorithm is not applied and a warning is raised.
+
+See the tutorial :ref:`constrainedlayout_guide`
+for more discussion of the algorithm with examples.
+"""
+
+import logging
+
+import numpy as np
+
+from matplotlib import _api, artist as martist
+import matplotlib.transforms as mtransforms
+import matplotlib._layoutgrid as mlayoutgrid
+
+
+_log = logging.getLogger(__name__)
+
+
+######################################################
+def do_constrained_layout(fig, h_pad, w_pad,
+                          hspace=None, wspace=None, rect=(0, 0, 1, 1),
+                          compress=False):
+    """
+    Do the constrained_layout.  Called at draw time in
+     ``figure.constrained_layout()``
+
+    Parameters
+    ----------
+    fig : `~matplotlib.figure.Figure`
+        `.Figure` instance to do the layout in.
+
+    h_pad, w_pad : float
+      Padding around the Axes elements in figure-normalized units.
+
+    hspace, wspace : float
+       Fraction of the figure to dedicate to space between the
+       Axes.  These are evenly spread between the gaps between the Axes.
+       A value of 0.2 for a three-column layout would have a space
+       of 0.1 of the figure width between each column.
+       If h/wspace < h/w_pad, then the pads are used instead.
+
+    rect : tuple of 4 floats
+        Rectangle in figure coordinates to perform constrained layout in
+        [left, bottom, width, height], each from 0-1.
+
+    compress : bool
+        Whether to shift Axes so that white space in between them is
+        removed. This is useful for simple grids of fixed-aspect Axes (e.g.
+        a grid of images).
+
+    Returns
+    -------
+    layoutgrid : private debugging structure
+    """
+
+    renderer = fig._get_renderer()
+    # make layoutgrid tree...
+    layoutgrids = make_layoutgrids(fig, None, rect=rect)
+    if not layoutgrids['hasgrids']:
+        _api.warn_external('There are no gridspecs with layoutgrids. '
+                           'Possibly did not call parent GridSpec with the'
+                           ' "figure" keyword')
+        return
+
+    for _ in range(2):
+        # do the algorithm twice.  This has to be done because decorations
+        # change size after the first re-position (i.e. x/yticklabels get
+        # larger/smaller).  This second reposition tends to be much milder,
+        # so doing twice makes things work OK.
+
+        # make margins for all the Axes and subfigures in the
+        # figure.  Add margins for colorbars...
+        make_layout_margins(layoutgrids, fig, renderer, h_pad=h_pad,
+                            w_pad=w_pad, hspace=hspace, wspace=wspace)
+        make_margin_suptitles(layoutgrids, fig, renderer, h_pad=h_pad,
+                              w_pad=w_pad)
+
+        # if a layout is such that a columns (or rows) margin has no
+        # constraints, we need to make all such instances in the grid
+        # match in margin size.
+        match_submerged_margins(layoutgrids, fig)
+
+        # update all the variables in the layout.
+        layoutgrids[fig].update_variables()
+
+        warn_collapsed = ('constrained_layout not applied because '
+                          'axes sizes collapsed to zero.  Try making '
+                          'figure larger or Axes decorations smaller.')
+        if check_no_collapsed_axes(layoutgrids, fig):
+            reposition_axes(layoutgrids, fig, renderer, h_pad=h_pad,
+                            w_pad=w_pad, hspace=hspace, wspace=wspace)
+            if compress:
+                layoutgrids = compress_fixed_aspect(layoutgrids, fig)
+                layoutgrids[fig].update_variables()
+                if check_no_collapsed_axes(layoutgrids, fig):
+                    reposition_axes(layoutgrids, fig, renderer, h_pad=h_pad,
+                                    w_pad=w_pad, hspace=hspace, wspace=wspace)
+                else:
+                    _api.warn_external(warn_collapsed)
+
+                if ((suptitle := fig._suptitle) is not None and
+                        suptitle.get_in_layout() and suptitle._autopos):
+                    x, _ = suptitle.get_position()
+                    suptitle.set_position(
+                        (x, layoutgrids[fig].get_inner_bbox().y1 + h_pad))
+                    suptitle.set_verticalalignment('bottom')
+        else:
+            _api.warn_external(warn_collapsed)
+        reset_margins(layoutgrids, fig)
+    return layoutgrids
+
+
+def make_layoutgrids(fig, layoutgrids, rect=(0, 0, 1, 1)):
+    """
+    Make the layoutgrid tree.
+
+    (Sub)Figures get a layoutgrid so we can have figure margins.
+
+    Gridspecs that are attached to Axes get a layoutgrid so Axes
+    can have margins.
+    """
+
+    if layoutgrids is None:
+        layoutgrids = dict()
+        layoutgrids['hasgrids'] = False
+    if not hasattr(fig, '_parent'):
+        # top figure;  pass rect as parent to allow user-specified
+        # margins
+        layoutgrids[fig] = mlayoutgrid.LayoutGrid(parent=rect, name='figlb')
+    else:
+        # subfigure
+        gs = fig._subplotspec.get_gridspec()
+        # it is possible the gridspec containing this subfigure hasn't
+        # been added to the tree yet:
+        layoutgrids = make_layoutgrids_gs(layoutgrids, gs)
+        # add the layoutgrid for the subfigure:
+        parentlb = layoutgrids[gs]
+        layoutgrids[fig] = mlayoutgrid.LayoutGrid(
+            parent=parentlb,
+            name='panellb',
+            parent_inner=True,
+            nrows=1, ncols=1,
+            parent_pos=(fig._subplotspec.rowspan,
+                        fig._subplotspec.colspan))
+    # recursively do all subfigures in this figure...
+    for sfig in fig.subfigs:
+        layoutgrids = make_layoutgrids(sfig, layoutgrids)
+
+    # for each Axes at the local level add its gridspec:
+    for ax in fig._localaxes:
+        gs = ax.get_gridspec()
+        if gs is not None:
+            layoutgrids = make_layoutgrids_gs(layoutgrids, gs)
+
+    return layoutgrids
+
+
+def make_layoutgrids_gs(layoutgrids, gs):
+    """
+    Make the layoutgrid for a gridspec (and anything nested in the gridspec)
+    """
+
+    if gs in layoutgrids or gs.figure is None:
+        return layoutgrids
+    # in order to do constrained_layout there has to be at least *one*
+    # gridspec in the tree:
+    layoutgrids['hasgrids'] = True
+    if not hasattr(gs, '_subplot_spec'):
+        # normal gridspec
+        parent = layoutgrids[gs.figure]
+        layoutgrids[gs] = mlayoutgrid.LayoutGrid(
+                parent=parent,
+                parent_inner=True,
+                name='gridspec',
+                ncols=gs._ncols, nrows=gs._nrows,
+                width_ratios=gs.get_width_ratios(),
+                height_ratios=gs.get_height_ratios())
+    else:
+        # this is a gridspecfromsubplotspec:
+        subplot_spec = gs._subplot_spec
+        parentgs = subplot_spec.get_gridspec()
+        # if a nested gridspec it is possible the parent is not in there yet:
+        if parentgs not in layoutgrids:
+            layoutgrids = make_layoutgrids_gs(layoutgrids, parentgs)
+        subspeclb = layoutgrids[parentgs]
+        # gridspecfromsubplotspec need an outer container:
+        # get a unique representation:
+        rep = (gs, 'top')
+        if rep not in layoutgrids:
+            layoutgrids[rep] = mlayoutgrid.LayoutGrid(
+                parent=subspeclb,
+                name='top',
+                nrows=1, ncols=1,
+                parent_pos=(subplot_spec.rowspan, subplot_spec.colspan))
+        layoutgrids[gs] = mlayoutgrid.LayoutGrid(
+                parent=layoutgrids[rep],
+                name='gridspec',
+                nrows=gs._nrows, ncols=gs._ncols,
+                width_ratios=gs.get_width_ratios(),
+                height_ratios=gs.get_height_ratios())
+    return layoutgrids
+
+
+def check_no_collapsed_axes(layoutgrids, fig):
+    """
+    Check that no Axes have collapsed to zero size.
+    """
+    for sfig in fig.subfigs:
+        ok = check_no_collapsed_axes(layoutgrids, sfig)
+        if not ok:
+            return False
+    for ax in fig.axes:
+        gs = ax.get_gridspec()
+        if gs in layoutgrids:  # also implies gs is not None.
+            lg = layoutgrids[gs]
+            for i in range(gs.nrows):
+                for j in range(gs.ncols):
+                    bb = lg.get_inner_bbox(i, j)
+                    if bb.width <= 0 or bb.height <= 0:
+                        return False
+    return True
+
+
+def compress_fixed_aspect(layoutgrids, fig):
+    gs = None
+    for ax in fig.axes:
+        if ax.get_subplotspec() is None:
+            continue
+        ax.apply_aspect()
+        sub = ax.get_subplotspec()
+        _gs = sub.get_gridspec()
+        if gs is None:
+            gs = _gs
+            extraw = np.zeros(gs.ncols)
+            extrah = np.zeros(gs.nrows)
+        elif _gs != gs:
+            raise ValueError('Cannot do compressed layout if Axes are not'
+                             'all from the same gridspec')
+        orig = ax.get_position(original=True)
+        actual = ax.get_position(original=False)
+        dw = orig.width - actual.width
+        if dw > 0:
+            extraw[sub.colspan] = np.maximum(extraw[sub.colspan], dw)
+        dh = orig.height - actual.height
+        if dh > 0:
+            extrah[sub.rowspan] = np.maximum(extrah[sub.rowspan], dh)
+
+    if gs is None:
+        raise ValueError('Cannot do compressed layout if no Axes '
+                         'are part of a gridspec.')
+    w = np.sum(extraw) / 2
+    layoutgrids[fig].edit_margin_min('left', w)
+    layoutgrids[fig].edit_margin_min('right', w)
+
+    h = np.sum(extrah) / 2
+    layoutgrids[fig].edit_margin_min('top', h)
+    layoutgrids[fig].edit_margin_min('bottom', h)
+    return layoutgrids
+
+
+def get_margin_from_padding(obj, *, w_pad=0, h_pad=0,
+                            hspace=0, wspace=0):
+
+    ss = obj._subplotspec
+    gs = ss.get_gridspec()
+
+    if hasattr(gs, 'hspace'):
+        _hspace = (gs.hspace if gs.hspace is not None else hspace)
+        _wspace = (gs.wspace if gs.wspace is not None else wspace)
+    else:
+        _hspace = (gs._hspace if gs._hspace is not None else hspace)
+        _wspace = (gs._wspace if gs._wspace is not None else wspace)
+
+    _wspace = _wspace / 2
+    _hspace = _hspace / 2
+
+    nrows, ncols = gs.get_geometry()
+    # there are two margins for each direction.  The "cb"
+    # margins are for pads and colorbars, the non-"cb" are
+    # for the Axes decorations (labels etc).
+    margin = {'leftcb': w_pad, 'rightcb': w_pad,
+              'bottomcb': h_pad, 'topcb': h_pad,
+              'left': 0, 'right': 0,
+              'top': 0, 'bottom': 0}
+    if _wspace / ncols > w_pad:
+        if ss.colspan.start > 0:
+            margin['leftcb'] = _wspace / ncols
+        if ss.colspan.stop < ncols:
+            margin['rightcb'] = _wspace / ncols
+    if _hspace / nrows > h_pad:
+        if ss.rowspan.stop < nrows:
+            margin['bottomcb'] = _hspace / nrows
+        if ss.rowspan.start > 0:
+            margin['topcb'] = _hspace / nrows
+
+    return margin
+
+
+def make_layout_margins(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0,
+                        hspace=0, wspace=0):
+    """
+    For each Axes, make a margin between the *pos* layoutbox and the
+    *axes* layoutbox be a minimum size that can accommodate the
+    decorations on the axis.
+
+    Then make room for colorbars.
+
+    Parameters
+    ----------
+    layoutgrids : dict
+    fig : `~matplotlib.figure.Figure`
+        `.Figure` instance to do the layout in.
+    renderer : `~matplotlib.backend_bases.RendererBase` subclass.
+        The renderer to use.
+    w_pad, h_pad : float, default: 0
+        Width and height padding (in fraction of figure).
+    hspace, wspace : float, default: 0
+        Width and height padding as fraction of figure size divided by
+        number of columns or rows.
+    """
+    for sfig in fig.subfigs:  # recursively make child panel margins
+        ss = sfig._subplotspec
+        gs = ss.get_gridspec()
+
+        make_layout_margins(layoutgrids, sfig, renderer,
+                            w_pad=w_pad, h_pad=h_pad,
+                            hspace=hspace, wspace=wspace)
+
+        margins = get_margin_from_padding(sfig, w_pad=0, h_pad=0,
+                                          hspace=hspace, wspace=wspace)
+        layoutgrids[gs].edit_outer_margin_mins(margins, ss)
+
+    for ax in fig._localaxes:
+        if not ax.get_subplotspec() or not ax.get_in_layout():
+            continue
+
+        ss = ax.get_subplotspec()
+        gs = ss.get_gridspec()
+
+        if gs not in layoutgrids:
+            return
+
+        margin = get_margin_from_padding(ax, w_pad=w_pad, h_pad=h_pad,
+                                         hspace=hspace, wspace=wspace)
+        pos, bbox = get_pos_and_bbox(ax, renderer)
+        # the margin is the distance between the bounding box of the Axes
+        # and its position (plus the padding from above)
+        margin['left'] += pos.x0 - bbox.x0
+        margin['right'] += bbox.x1 - pos.x1
+        # remember that rows are ordered from top:
+        margin['bottom'] += pos.y0 - bbox.y0
+        margin['top'] += bbox.y1 - pos.y1
+
+        # make margin for colorbars.  These margins go in the
+        # padding margin, versus the margin for Axes decorators.
+        for cbax in ax._colorbars:
+            # note pad is a fraction of the parent width...
+            pad = colorbar_get_pad(layoutgrids, cbax)
+            # colorbars can be child of more than one subplot spec:
+            cbp_rspan, cbp_cspan = get_cb_parent_spans(cbax)
+            loc = cbax._colorbar_info['location']
+            cbpos, cbbbox = get_pos_and_bbox(cbax, renderer)
+            if loc == 'right':
+                if cbp_cspan.stop == ss.colspan.stop:
+                    # only increase if the colorbar is on the right edge
+                    margin['rightcb'] += cbbbox.width + pad
+            elif loc == 'left':
+                if cbp_cspan.start == ss.colspan.start:
+                    # only increase if the colorbar is on the left edge
+                    margin['leftcb'] += cbbbox.width + pad
+            elif loc == 'top':
+                if cbp_rspan.start == ss.rowspan.start:
+                    margin['topcb'] += cbbbox.height + pad
+            else:
+                if cbp_rspan.stop == ss.rowspan.stop:
+                    margin['bottomcb'] += cbbbox.height + pad
+            # If the colorbars are wider than the parent box in the
+            # cross direction
+            if loc in ['top', 'bottom']:
+                if (cbp_cspan.start == ss.colspan.start and
+                        cbbbox.x0 < bbox.x0):
+                    margin['left'] += bbox.x0 - cbbbox.x0
+                if (cbp_cspan.stop == ss.colspan.stop and
+                        cbbbox.x1 > bbox.x1):
+                    margin['right'] += cbbbox.x1 - bbox.x1
+            # or taller:
+            if loc in ['left', 'right']:
+                if (cbp_rspan.stop == ss.rowspan.stop and
+                        cbbbox.y0 < bbox.y0):
+                    margin['bottom'] += bbox.y0 - cbbbox.y0
+                if (cbp_rspan.start == ss.rowspan.start and
+                        cbbbox.y1 > bbox.y1):
+                    margin['top'] += cbbbox.y1 - bbox.y1
+        # pass the new margins down to the layout grid for the solution...
+        layoutgrids[gs].edit_outer_margin_mins(margin, ss)
+
+    # make margins for figure-level legends:
+    for leg in fig.legends:
+        inv_trans_fig = None
+        if leg._outside_loc and leg._bbox_to_anchor is None:
+            if inv_trans_fig is None:
+                inv_trans_fig = fig.transFigure.inverted().transform_bbox
+            bbox = inv_trans_fig(leg.get_tightbbox(renderer))
+            w = bbox.width + 2 * w_pad
+            h = bbox.height + 2 * h_pad
+            legendloc = leg._outside_loc
+            if legendloc == 'lower':
+                layoutgrids[fig].edit_margin_min('bottom', h)
+            elif legendloc == 'upper':
+                layoutgrids[fig].edit_margin_min('top', h)
+            if legendloc == 'right':
+                layoutgrids[fig].edit_margin_min('right', w)
+            elif legendloc == 'left':
+                layoutgrids[fig].edit_margin_min('left', w)
+
+
+def make_margin_suptitles(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0):
+    # Figure out how large the suptitle is and make the
+    # top level figure margin larger.
+
+    inv_trans_fig = fig.transFigure.inverted().transform_bbox
+    # get the h_pad and w_pad as distances in the local subfigure coordinates:
+    padbox = mtransforms.Bbox([[0, 0], [w_pad, h_pad]])
+    padbox = (fig.transFigure -
+              fig.transSubfigure).transform_bbox(padbox)
+    h_pad_local = padbox.height
+    w_pad_local = padbox.width
+
+    for sfig in fig.subfigs:
+        make_margin_suptitles(layoutgrids, sfig, renderer,
+                              w_pad=w_pad, h_pad=h_pad)
+
+    if fig._suptitle is not None and fig._suptitle.get_in_layout():
+        p = fig._suptitle.get_position()
+        if getattr(fig._suptitle, '_autopos', False):
+            fig._suptitle.set_position((p[0], 1 - h_pad_local))
+            bbox = inv_trans_fig(fig._suptitle.get_tightbbox(renderer))
+            layoutgrids[fig].edit_margin_min('top', bbox.height + 2 * h_pad)
+
+    if fig._supxlabel is not None and fig._supxlabel.get_in_layout():
+        p = fig._supxlabel.get_position()
+        if getattr(fig._supxlabel, '_autopos', False):
+            fig._supxlabel.set_position((p[0], h_pad_local))
+            bbox = inv_trans_fig(fig._supxlabel.get_tightbbox(renderer))
+            layoutgrids[fig].edit_margin_min('bottom',
+                                             bbox.height + 2 * h_pad)
+
+    if fig._supylabel is not None and fig._supylabel.get_in_layout():
+        p = fig._supylabel.get_position()
+        if getattr(fig._supylabel, '_autopos', False):
+            fig._supylabel.set_position((w_pad_local, p[1]))
+            bbox = inv_trans_fig(fig._supylabel.get_tightbbox(renderer))
+            layoutgrids[fig].edit_margin_min('left', bbox.width + 2 * w_pad)
+
+
+def match_submerged_margins(layoutgrids, fig):
+    """
+    Make the margins that are submerged inside an Axes the same size.
+
+    This allows Axes that span two columns (or rows) that are offset
+    from one another to have the same size.
+
+    This gives the proper layout for something like::
+        fig = plt.figure(constrained_layout=True)
+        axs = fig.subplot_mosaic("AAAB\nCCDD")
+
+    Without this routine, the Axes D will be wider than C, because the
+    margin width between the two columns in C has no width by default,
+    whereas the margins between the two columns of D are set by the
+    width of the margin between A and B. However, obviously the user would
+    like C and D to be the same size, so we need to add constraints to these
+    "submerged" margins.
+
+    This routine makes all the interior margins the same, and the spacing
+    between the three columns in A and the two column in C are all set to the
+    margins between the two columns of D.
+
+    See test_constrained_layout::test_constrained_layout12 for an example.
+    """
+
+    for sfig in fig.subfigs:
+        match_submerged_margins(layoutgrids, sfig)
+
+    axs = [a for a in fig.get_axes()
+           if a.get_subplotspec() is not None and a.get_in_layout()]
+
+    for ax1 in axs:
+        ss1 = ax1.get_subplotspec()
+        if ss1.get_gridspec() not in layoutgrids:
+            axs.remove(ax1)
+            continue
+        lg1 = layoutgrids[ss1.get_gridspec()]
+
+        # interior columns:
+        if len(ss1.colspan) > 1:
+            maxsubl = np.max(
+                lg1.margin_vals['left'][ss1.colspan[1:]] +
+                lg1.margin_vals['leftcb'][ss1.colspan[1:]]
+            )
+            maxsubr = np.max(
+                lg1.margin_vals['right'][ss1.colspan[:-1]] +
+                lg1.margin_vals['rightcb'][ss1.colspan[:-1]]
+            )
+            for ax2 in axs:
+                ss2 = ax2.get_subplotspec()
+                lg2 = layoutgrids[ss2.get_gridspec()]
+                if lg2 is not None and len(ss2.colspan) > 1:
+                    maxsubl2 = np.max(
+                        lg2.margin_vals['left'][ss2.colspan[1:]] +
+                        lg2.margin_vals['leftcb'][ss2.colspan[1:]])
+                    if maxsubl2 > maxsubl:
+                        maxsubl = maxsubl2
+                    maxsubr2 = np.max(
+                        lg2.margin_vals['right'][ss2.colspan[:-1]] +
+                        lg2.margin_vals['rightcb'][ss2.colspan[:-1]])
+                    if maxsubr2 > maxsubr:
+                        maxsubr = maxsubr2
+            for i in ss1.colspan[1:]:
+                lg1.edit_margin_min('left', maxsubl, cell=i)
+            for i in ss1.colspan[:-1]:
+                lg1.edit_margin_min('right', maxsubr, cell=i)
+
+        # interior rows:
+        if len(ss1.rowspan) > 1:
+            maxsubt = np.max(
+                lg1.margin_vals['top'][ss1.rowspan[1:]] +
+                lg1.margin_vals['topcb'][ss1.rowspan[1:]]
+            )
+            maxsubb = np.max(
+                lg1.margin_vals['bottom'][ss1.rowspan[:-1]] +
+                lg1.margin_vals['bottomcb'][ss1.rowspan[:-1]]
+            )
+
+            for ax2 in axs:
+                ss2 = ax2.get_subplotspec()
+                lg2 = layoutgrids[ss2.get_gridspec()]
+                if lg2 is not None:
+                    if len(ss2.rowspan) > 1:
+                        maxsubt = np.max([np.max(
+                            lg2.margin_vals['top'][ss2.rowspan[1:]] +
+                            lg2.margin_vals['topcb'][ss2.rowspan[1:]]
+                        ), maxsubt])
+                        maxsubb = np.max([np.max(
+                            lg2.margin_vals['bottom'][ss2.rowspan[:-1]] +
+                            lg2.margin_vals['bottomcb'][ss2.rowspan[:-1]]
+                        ), maxsubb])
+            for i in ss1.rowspan[1:]:
+                lg1.edit_margin_min('top', maxsubt, cell=i)
+            for i in ss1.rowspan[:-1]:
+                lg1.edit_margin_min('bottom', maxsubb, cell=i)
+
+
+def get_cb_parent_spans(cbax):
+    """
+    Figure out which subplotspecs this colorbar belongs to.
+
+    Parameters
+    ----------
+    cbax : `~matplotlib.axes.Axes`
+        Axes for the colorbar.
+    """
+    rowstart = np.inf
+    rowstop = -np.inf
+    colstart = np.inf
+    colstop = -np.inf
+    for parent in cbax._colorbar_info['parents']:
+        ss = parent.get_subplotspec()
+        rowstart = min(ss.rowspan.start, rowstart)
+        rowstop = max(ss.rowspan.stop, rowstop)
+        colstart = min(ss.colspan.start, colstart)
+        colstop = max(ss.colspan.stop, colstop)
+
+    rowspan = range(rowstart, rowstop)
+    colspan = range(colstart, colstop)
+    return rowspan, colspan
+
+
+def get_pos_and_bbox(ax, renderer):
+    """
+    Get the position and the bbox for the Axes.
+
+    Parameters
+    ----------
+    ax : `~matplotlib.axes.Axes`
+    renderer : `~matplotlib.backend_bases.RendererBase` subclass.
+
+    Returns
+    -------
+    pos : `~matplotlib.transforms.Bbox`
+        Position in figure coordinates.
+    bbox : `~matplotlib.transforms.Bbox`
+        Tight bounding box in figure coordinates.
+    """
+    fig = ax.get_figure(root=False)
+    pos = ax.get_position(original=True)
+    # pos is in panel co-ords, but we need in figure for the layout
+    pos = pos.transformed(fig.transSubfigure - fig.transFigure)
+    tightbbox = martist._get_tightbbox_for_layout_only(ax, renderer)
+    if tightbbox is None:
+        bbox = pos
+    else:
+        bbox = tightbbox.transformed(fig.transFigure.inverted())
+    return pos, bbox
+
+
+def reposition_axes(layoutgrids, fig, renderer, *,
+                    w_pad=0, h_pad=0, hspace=0, wspace=0):
+    """
+    Reposition all the Axes based on the new inner bounding box.
+    """
+    trans_fig_to_subfig = fig.transFigure - fig.transSubfigure
+    for sfig in fig.subfigs:
+        bbox = layoutgrids[sfig].get_outer_bbox()
+        sfig._redo_transform_rel_fig(
+            bbox=bbox.transformed(trans_fig_to_subfig))
+        reposition_axes(layoutgrids, sfig, renderer,
+                        w_pad=w_pad, h_pad=h_pad,
+                        wspace=wspace, hspace=hspace)
+
+    for ax in fig._localaxes:
+        if ax.get_subplotspec() is None or not ax.get_in_layout():
+            continue
+
+        # grid bbox is in Figure coordinates, but we specify in panel
+        # coordinates...
+        ss = ax.get_subplotspec()
+        gs = ss.get_gridspec()
+        if gs not in layoutgrids:
+            return
+
+        bbox = layoutgrids[gs].get_inner_bbox(rows=ss.rowspan,
+                                              cols=ss.colspan)
+
+        # transform from figure to panel for set_position:
+        newbbox = trans_fig_to_subfig.transform_bbox(bbox)
+        ax._set_position(newbbox)
+
+        # move the colorbars:
+        # we need to keep track of oldw and oldh if there is more than
+        # one colorbar:
+        offset = {'left': 0, 'right': 0, 'bottom': 0, 'top': 0}
+        for nn, cbax in enumerate(ax._colorbars[::-1]):
+            if ax == cbax._colorbar_info['parents'][0]:
+                reposition_colorbar(layoutgrids, cbax, renderer,
+                                    offset=offset)
+
+
+def reposition_colorbar(layoutgrids, cbax, renderer, *, offset=None):
+    """
+    Place the colorbar in its new place.
+
+    Parameters
+    ----------
+    layoutgrids : dict
+    cbax : `~matplotlib.axes.Axes`
+        Axes for the colorbar.
+    renderer : `~matplotlib.backend_bases.RendererBase` subclass.
+        The renderer to use.
+    offset : array-like
+        Offset the colorbar needs to be pushed to in order to
+        account for multiple colorbars.
+    """
+
+    parents = cbax._colorbar_info['parents']
+    gs = parents[0].get_gridspec()
+    fig = cbax.get_figure(root=False)
+    trans_fig_to_subfig = fig.transFigure - fig.transSubfigure
+
+    cb_rspans, cb_cspans = get_cb_parent_spans(cbax)
+    bboxparent = layoutgrids[gs].get_bbox_for_cb(rows=cb_rspans,
+                                                 cols=cb_cspans)
+    pb = layoutgrids[gs].get_inner_bbox(rows=cb_rspans, cols=cb_cspans)
+
+    location = cbax._colorbar_info['location']
+    anchor = cbax._colorbar_info['anchor']
+    fraction = cbax._colorbar_info['fraction']
+    aspect = cbax._colorbar_info['aspect']
+    shrink = cbax._colorbar_info['shrink']
+
+    cbpos, cbbbox = get_pos_and_bbox(cbax, renderer)
+
+    # Colorbar gets put at extreme edge of outer bbox of the subplotspec
+    # It needs to be moved in by: 1) a pad 2) its "margin" 3) by
+    # any colorbars already added at this location:
+    cbpad = colorbar_get_pad(layoutgrids, cbax)
+    if location in ('left', 'right'):
+        # fraction and shrink are fractions of parent
+        pbcb = pb.shrunk(fraction, shrink).anchored(anchor, pb)
+        # The colorbar is at the left side of the parent.  Need
+        # to translate to right (or left)
+        if location == 'right':
+            lmargin = cbpos.x0 - cbbbox.x0
+            dx = bboxparent.x1 - pbcb.x0 + offset['right']
+            dx += cbpad + lmargin
+            offset['right'] += cbbbox.width + cbpad
+            pbcb = pbcb.translated(dx, 0)
+        else:
+            lmargin = cbpos.x0 - cbbbox.x0
+            dx = bboxparent.x0 - pbcb.x0  # edge of parent
+            dx += -cbbbox.width - cbpad + lmargin - offset['left']
+            offset['left'] += cbbbox.width + cbpad
+            pbcb = pbcb.translated(dx, 0)
+    else:  # horizontal axes:
+        pbcb = pb.shrunk(shrink, fraction).anchored(anchor, pb)
+        if location == 'top':
+            bmargin = cbpos.y0 - cbbbox.y0
+            dy = bboxparent.y1 - pbcb.y0 + offset['top']
+            dy += cbpad + bmargin
+            offset['top'] += cbbbox.height + cbpad
+            pbcb = pbcb.translated(0, dy)
+        else:
+            bmargin = cbpos.y0 - cbbbox.y0
+            dy = bboxparent.y0 - pbcb.y0
+            dy += -cbbbox.height - cbpad + bmargin - offset['bottom']
+            offset['bottom'] += cbbbox.height + cbpad
+            pbcb = pbcb.translated(0, dy)
+
+    pbcb = trans_fig_to_subfig.transform_bbox(pbcb)
+    cbax.set_transform(fig.transSubfigure)
+    cbax._set_position(pbcb)
+    cbax.set_anchor(anchor)
+    if location in ['bottom', 'top']:
+        aspect = 1 / aspect
+    cbax.set_box_aspect(aspect)
+    cbax.set_aspect('auto')
+    return offset
+
+
+def reset_margins(layoutgrids, fig):
+    """
+    Reset the margins in the layoutboxes of *fig*.
+
+    Margins are usually set as a minimum, so if the figure gets smaller
+    the minimum needs to be zero in order for it to grow again.
+    """
+    for sfig in fig.subfigs:
+        reset_margins(layoutgrids, sfig)
+    for ax in fig.axes:
+        if ax.get_in_layout():
+            gs = ax.get_gridspec()
+            if gs in layoutgrids:  # also implies gs is not None.
+                layoutgrids[gs].reset_margins()
+    layoutgrids[fig].reset_margins()
+
+
+def colorbar_get_pad(layoutgrids, cax):
+    parents = cax._colorbar_info['parents']
+    gs = parents[0].get_gridspec()
+
+    cb_rspans, cb_cspans = get_cb_parent_spans(cax)
+    bboxouter = layoutgrids[gs].get_inner_bbox(rows=cb_rspans, cols=cb_cspans)
+
+    if cax._colorbar_info['location'] in ['right', 'left']:
+        size = bboxouter.width
+    else:
+        size = bboxouter.height
+
+    return cax._colorbar_info['pad'] * size

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

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

infer_4_30_0/lib/python3.10/site-packages/matplotlib/_docstring.pyi

@@ -0,0 +1,34 @@
+from collections.abc import Callable
+from typing import Any, TypeVar, overload
+
+
+_T = TypeVar('_T')
+
+
+def kwarg_doc(text: str) -> Callable[[_T], _T]: ...
+
+
+class Substitution:
+    @overload
+    def __init__(self, *args: str): ...
+    @overload
+    def __init__(self, **kwargs: str): ...
+    def __call__(self, func: _T) -> _T: ...
+    def update(self, *args, **kwargs): ...  # type: ignore[no-untyped-def]
+
+
+class _ArtistKwdocLoader(dict[str, str]):
+    def __missing__(self, key: str) -> str: ...
+
+
+class _ArtistPropertiesSubstitution:
+    def __init__(self) -> None: ...
+    def register(self, **kwargs) -> None: ...
+    def __call__(self, obj: _T) -> _T: ...
+
+
+def copy(source: Any) -> Callable[[_T], _T]: ...
+
+
+dedent_interpd: _ArtistPropertiesSubstitution
+interpd: _ArtistPropertiesSubstitution

infer_4_30_0/lib/python3.10/site-packages/matplotlib/_enums.py

@@ -0,0 +1,177 @@
+"""
+Enums representing sets of strings that Matplotlib uses as input parameters.
+
+Matplotlib often uses simple data types like strings or tuples to define a
+concept; e.g. the line capstyle can be specified as one of 'butt', 'round',
+or 'projecting'. The classes in this module are used internally and serve to
+document these concepts formally.
+
+As an end-user you will not use these classes directly, but only the values
+they define.
+"""
+
+from enum import Enum
+from matplotlib import _docstring
+
+
+class JoinStyle(str, Enum):
+    """
+    Define how the connection between two line segments is drawn.
+
+    For a visual impression of each *JoinStyle*, `view these docs online
+    <JoinStyle>`, or run `JoinStyle.demo`.
+
+    Lines in Matplotlib are typically defined by a 1D `~.path.Path` and a
+    finite ``linewidth``, where the underlying 1D `~.path.Path` represents the
+    center of the stroked line.
+
+    By default, `~.backend_bases.GraphicsContextBase` defines the boundaries of
+    a stroked line to simply be every point within some radius,
+    ``linewidth/2``, away from any point of the center line. However, this
+    results in corners appearing "rounded", which may not be the desired
+    behavior if you are drawing, for example, a polygon or pointed star.
+
+    **Supported values:**
+
+    .. rst-class:: value-list
+
+        'miter'
+            the "arrow-tip" style. Each boundary of the filled-in area will
+            extend in a straight line parallel to the tangent vector of the
+            centerline at the point it meets the corner, until they meet in a
+            sharp point.
+        'round'
+            stokes every point within a radius of ``linewidth/2`` of the center
+            lines.
+        'bevel'
+            the "squared-off" style. It can be thought of as a rounded corner
+            where the "circular" part of the corner has been cut off.
+
+    .. note::
+
+        Very long miter tips are cut off (to form a *bevel*) after a
+        backend-dependent limit called the "miter limit", which specifies the
+        maximum allowed ratio of miter length to line width. For example, the
+        PDF backend uses the default value of 10 specified by the PDF standard,
+        while the SVG backend does not even specify the miter limit, resulting
+        in a default value of 4 per the SVG specification. Matplotlib does not
+        currently allow the user to adjust this parameter.
+
+        A more detailed description of the effect of a miter limit can be found
+        in the `Mozilla Developer Docs
+        <https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-miterlimit>`_
+
+    .. plot::
+        :alt: Demo of possible JoinStyle's
+
+        from matplotlib._enums import JoinStyle
+        JoinStyle.demo()
+
+    """
+
+    miter = "miter"
+    round = "round"
+    bevel = "bevel"
+
+    @staticmethod
+    def demo():
+        """Demonstrate how each JoinStyle looks for various join angles."""
+        import numpy as np
+        import matplotlib.pyplot as plt
+
+        def plot_angle(ax, x, y, angle, style):
+            phi = np.radians(angle)
+            xx = [x + .5, x, x + .5*np.cos(phi)]
+            yy = [y, y, y + .5*np.sin(phi)]
+            ax.plot(xx, yy, lw=12, color='tab:blue', solid_joinstyle=style)
+            ax.plot(xx, yy, lw=1, color='black')
+            ax.plot(xx[1], yy[1], 'o', color='tab:red', markersize=3)
+
+        fig, ax = plt.subplots(figsize=(5, 4), constrained_layout=True)
+        ax.set_title('Join style')
+        for x, style in enumerate(['miter', 'round', 'bevel']):
+            ax.text(x, 5, style)
+            for y, angle in enumerate([20, 45, 60, 90, 120]):
+                plot_angle(ax, x, y, angle, style)
+                if x == 0:
+                    ax.text(-1.3, y, f'{angle} degrees')
+        ax.set_xlim(-1.5, 2.75)
+        ax.set_ylim(-.5, 5.5)
+        ax.set_axis_off()
+        fig.show()
+
+
+JoinStyle.input_description = "{" \
+        + ", ".join([f"'{js.name}'" for js in JoinStyle]) \
+        + "}"
+
+
+class CapStyle(str, Enum):
+    r"""
+    Define how the two endpoints (caps) of an unclosed line are drawn.
+
+    How to draw the start and end points of lines that represent a closed curve
+    (i.e. that end in a `~.path.Path.CLOSEPOLY`) is controlled by the line's
+    `JoinStyle`. For all other lines, how the start and end points are drawn is
+    controlled by the *CapStyle*.
+
+    For a visual impression of each *CapStyle*, `view these docs online
+    <CapStyle>` or run `CapStyle.demo`.
+
+    By default, `~.backend_bases.GraphicsContextBase` draws a stroked line as
+    squared off at its endpoints.
+
+    **Supported values:**
+
+    .. rst-class:: value-list
+
+        'butt'
+            the line is squared off at its endpoint.
+        'projecting'
+            the line is squared off as in *butt*, but the filled in area
+            extends beyond the endpoint a distance of ``linewidth/2``.
+        'round'
+            like *butt*, but a semicircular cap is added to the end of the
+            line, of radius ``linewidth/2``.
+
+    .. plot::
+        :alt: Demo of possible CapStyle's
+
+        from matplotlib._enums import CapStyle
+        CapStyle.demo()
+
+    """
+    butt = "butt"
+    projecting = "projecting"
+    round = "round"
+
+    @staticmethod
+    def demo():
+        """Demonstrate how each CapStyle looks for a thick line segment."""
+        import matplotlib.pyplot as plt
+
+        fig = plt.figure(figsize=(4, 1.2))
+        ax = fig.add_axes([0, 0, 1, 0.8])
+        ax.set_title('Cap style')
+
+        for x, style in enumerate(['butt', 'round', 'projecting']):
+            ax.text(x+0.25, 0.85, style, ha='center')
+            xx = [x, x+0.5]
+            yy = [0, 0]
+            ax.plot(xx, yy, lw=12, color='tab:blue', solid_capstyle=style)
+            ax.plot(xx, yy, lw=1, color='black')
+            ax.plot(xx, yy, 'o', color='tab:red', markersize=3)
+
+        ax.set_ylim(-.5, 1.5)
+        ax.set_axis_off()
+        fig.show()
+
+
+CapStyle.input_description = "{" \
+        + ", ".join([f"'{cs.name}'" for cs in CapStyle]) \
+        + "}"
+
+_docstring.interpd.register(
+    JoinStyle=JoinStyle.input_description,
+    CapStyle=CapStyle.input_description,
+)

infer_4_30_0/lib/python3.10/site-packages/matplotlib/_mathtext_data.py

@@ -0,0 +1,1742 @@
+"""
+font data tables for truetype and afm computer modern fonts
+"""
+
+from __future__ import annotations
+from typing import overload
+
+latex_to_bakoma = {
+    '\\__sqrt__'                 : ('cmex10', 0x70),
+    '\\bigcap'                   : ('cmex10', 0x5c),
+    '\\bigcup'                   : ('cmex10', 0x5b),
+    '\\bigodot'                  : ('cmex10', 0x4b),
+    '\\bigoplus'                 : ('cmex10', 0x4d),
+    '\\bigotimes'                : ('cmex10', 0x4f),
+    '\\biguplus'                 : ('cmex10', 0x5d),
+    '\\bigvee'                   : ('cmex10', 0x5f),
+    '\\bigwedge'                 : ('cmex10', 0x5e),
+    '\\coprod'                   : ('cmex10', 0x61),
+    '\\int'                      : ('cmex10', 0x5a),
+    '\\langle'                   : ('cmex10', 0xad),
+    '\\leftangle'                : ('cmex10', 0xad),
+    '\\leftbrace'                : ('cmex10', 0xa9),
+    '\\oint'                     : ('cmex10', 0x49),
+    '\\prod'                     : ('cmex10', 0x59),
+    '\\rangle'                   : ('cmex10', 0xae),
+    '\\rightangle'               : ('cmex10', 0xae),
+    '\\rightbrace'               : ('cmex10', 0xaa),
+    '\\sum'                      : ('cmex10', 0x58),
+    '\\widehat'                  : ('cmex10', 0x62),
+    '\\widetilde'                : ('cmex10', 0x65),
+    '\\{'                        : ('cmex10', 0xa9),
+    '\\}'                        : ('cmex10', 0xaa),
+    '{'                          : ('cmex10', 0xa9),
+    '}'                          : ('cmex10', 0xaa),
+
+    ','                          : ('cmmi10', 0x3b),
+    '.'                          : ('cmmi10', 0x3a),
+    '/'                          : ('cmmi10', 0x3d),
+    '<'                          : ('cmmi10', 0x3c),
+    '>'                          : ('cmmi10', 0x3e),
+    '\\alpha'                    : ('cmmi10', 0xae),
+    '\\beta'                     : ('cmmi10', 0xaf),
+    '\\chi'                      : ('cmmi10', 0xc2),
+    '\\combiningrightarrowabove' : ('cmmi10', 0x7e),
+    '\\delta'                    : ('cmmi10', 0xb1),
+    '\\ell'                      : ('cmmi10', 0x60),
+    '\\epsilon'                  : ('cmmi10', 0xb2),
+    '\\eta'                      : ('cmmi10', 0xb4),
+    '\\flat'                     : ('cmmi10', 0x5b),
+    '\\frown'                    : ('cmmi10', 0x5f),
+    '\\gamma'                    : ('cmmi10', 0xb0),
+    '\\imath'                    : ('cmmi10', 0x7b),
+    '\\iota'                     : ('cmmi10', 0xb6),
+    '\\jmath'                    : ('cmmi10', 0x7c),
+    '\\kappa'                    : ('cmmi10', 0x2219),
+    '\\lambda'                   : ('cmmi10', 0xb8),
+    '\\leftharpoondown'          : ('cmmi10', 0x29),
+    '\\leftharpoonup'            : ('cmmi10', 0x28),
+    '\\mu'                       : ('cmmi10', 0xb9),
+    '\\natural'                  : ('cmmi10', 0x5c),
+    '\\nu'                       : ('cmmi10', 0xba),
+    '\\omega'                    : ('cmmi10', 0x21),
+    '\\phi'                      : ('cmmi10', 0xc1),
+    '\\pi'                       : ('cmmi10', 0xbc),
+    '\\psi'                      : ('cmmi10', 0xc3),
+    '\\rho'                      : ('cmmi10', 0xbd),
+    '\\rightharpoondown'         : ('cmmi10', 0x2b),
+    '\\rightharpoonup'           : ('cmmi10', 0x2a),
+    '\\sharp'                    : ('cmmi10', 0x5d),
+    '\\sigma'                    : ('cmmi10', 0xbe),
+    '\\smile'                    : ('cmmi10', 0x5e),
+    '\\tau'                      : ('cmmi10', 0xbf),
+    '\\theta'                    : ('cmmi10', 0xb5),
+    '\\triangleleft'             : ('cmmi10', 0x2f),
+    '\\triangleright'            : ('cmmi10', 0x2e),
+    '\\upsilon'                  : ('cmmi10', 0xc0),
+    '\\varepsilon'               : ('cmmi10', 0x22),
+    '\\varphi'                   : ('cmmi10', 0x27),
+    '\\varrho'                   : ('cmmi10', 0x25),
+    '\\varsigma'                 : ('cmmi10', 0x26),
+    '\\vartheta'                 : ('cmmi10', 0x23),
+    '\\wp'                       : ('cmmi10', 0x7d),
+    '\\xi'                       : ('cmmi10', 0xbb),
+    '\\zeta'                     : ('cmmi10', 0xb3),
+
+    '!'                          : ('cmr10', 0x21),
+    '%'                          : ('cmr10', 0x25),
+    '&'                          : ('cmr10', 0x26),
+    '('                          : ('cmr10', 0x28),
+    ')'                          : ('cmr10', 0x29),
+    '+'                          : ('cmr10', 0x2b),
+    '0'                          : ('cmr10', 0x30),
+    '1'                          : ('cmr10', 0x31),
+    '2'                          : ('cmr10', 0x32),
+    '3'                          : ('cmr10', 0x33),
+    '4'                          : ('cmr10', 0x34),
+    '5'                          : ('cmr10', 0x35),
+    '6'                          : ('cmr10', 0x36),
+    '7'                          : ('cmr10', 0x37),
+    '8'                          : ('cmr10', 0x38),
+    '9'                          : ('cmr10', 0x39),
+    ':'                          : ('cmr10', 0x3a),
+    ';'                          : ('cmr10', 0x3b),
+    '='                          : ('cmr10', 0x3d),
+    '?'                          : ('cmr10', 0x3f),
+    '@'                          : ('cmr10', 0x40),
+    '['                          : ('cmr10', 0x5b),
+    '\\#'                        : ('cmr10', 0x23),
+    '\\$'                        : ('cmr10', 0x24),
+    '\\%'                        : ('cmr10', 0x25),
+    '\\Delta'                    : ('cmr10', 0xa2),
+    '\\Gamma'                    : ('cmr10', 0xa1),
+    '\\Lambda'                   : ('cmr10', 0xa4),
+    '\\Omega'                    : ('cmr10', 0xad),
+    '\\Phi'                      : ('cmr10', 0xa9),
+    '\\Pi'                       : ('cmr10', 0xa6),
+    '\\Psi'                      : ('cmr10', 0xaa),
+    '\\Sigma'                    : ('cmr10', 0xa7),
+    '\\Theta'                    : ('cmr10', 0xa3),
+    '\\Upsilon'                  : ('cmr10', 0xa8),
+    '\\Xi'                       : ('cmr10', 0xa5),
+    '\\circumflexaccent'         : ('cmr10', 0x5e),
+    '\\combiningacuteaccent'     : ('cmr10', 0xb6),
+    '\\combiningbreve'           : ('cmr10', 0xb8),
+    '\\combiningdiaeresis'       : ('cmr10', 0xc4),
+    '\\combiningdotabove'        : ('cmr10', 0x5f),
+    '\\combininggraveaccent'     : ('cmr10', 0xb5),
+    '\\combiningoverline'        : ('cmr10', 0xb9),
+    '\\combiningtilde'           : ('cmr10', 0x7e),
+    '\\leftbracket'              : ('cmr10', 0x5b),
+    '\\leftparen'                : ('cmr10', 0x28),
+    '\\rightbracket'             : ('cmr10', 0x5d),
+    '\\rightparen'               : ('cmr10', 0x29),
+    '\\widebar'                  : ('cmr10', 0xb9),
+    ']'                          : ('cmr10', 0x5d),
+
+    '*'                          : ('cmsy10', 0xa4),
+    '\N{MINUS SIGN}'             : ('cmsy10', 0xa1),
+    '\\Downarrow'                : ('cmsy10', 0x2b),
+    '\\Im'                       : ('cmsy10', 0x3d),
+    '\\Leftarrow'                : ('cmsy10', 0x28),
+    '\\Leftrightarrow'           : ('cmsy10', 0x2c),
+    '\\P'                        : ('cmsy10', 0x7b),
+    '\\Re'                       : ('cmsy10', 0x3c),
+    '\\Rightarrow'               : ('cmsy10', 0x29),
+    '\\S'                        : ('cmsy10', 0x78),
+    '\\Uparrow'                  : ('cmsy10', 0x2a),
+    '\\Updownarrow'              : ('cmsy10', 0x6d),
+    '\\Vert'                     : ('cmsy10', 0x6b),
+    '\\aleph'                    : ('cmsy10', 0x40),
+    '\\approx'                   : ('cmsy10', 0xbc),
+    '\\ast'                      : ('cmsy10', 0xa4),
+    '\\asymp'                    : ('cmsy10', 0xb3),
+    '\\backslash'                : ('cmsy10', 0x6e),
+    '\\bigcirc'                  : ('cmsy10', 0xb0),
+    '\\bigtriangledown'          : ('cmsy10', 0x35),
+    '\\bigtriangleup'            : ('cmsy10', 0x34),
+    '\\bot'                      : ('cmsy10', 0x3f),
+    '\\bullet'                   : ('cmsy10', 0xb2),
+    '\\cap'                      : ('cmsy10', 0x5c),
+    '\\cdot'                     : ('cmsy10', 0xa2),
+    '\\circ'                     : ('cmsy10', 0xb1),
+    '\\clubsuit'                 : ('cmsy10', 0x7c),
+    '\\cup'                      : ('cmsy10', 0x5b),
+    '\\dag'                      : ('cmsy10', 0x79),
+    '\\dashv'                    : ('cmsy10', 0x61),
+    '\\ddag'                     : ('cmsy10', 0x7a),
+    '\\diamond'                  : ('cmsy10', 0xa6),
+    '\\diamondsuit'              : ('cmsy10', 0x7d),
+    '\\div'                      : ('cmsy10', 0xa5),
+    '\\downarrow'                : ('cmsy10', 0x23),
+    '\\emptyset'                 : ('cmsy10', 0x3b),
+    '\\equiv'                    : ('cmsy10', 0xb4),
+    '\\exists'                   : ('cmsy10', 0x39),
+    '\\forall'                   : ('cmsy10', 0x38),
+    '\\geq'                      : ('cmsy10', 0xb8),
+    '\\gg'                       : ('cmsy10', 0xc0),
+    '\\heartsuit'                : ('cmsy10', 0x7e),
+    '\\in'                       : ('cmsy10', 0x32),
+    '\\infty'                    : ('cmsy10', 0x31),
+    '\\lbrace'                   : ('cmsy10', 0x66),
+    '\\lceil'                    : ('cmsy10', 0x64),
+    '\\leftarrow'                : ('cmsy10', 0xc3),
+    '\\leftrightarrow'           : ('cmsy10', 0x24),
+    '\\leq'                      : ('cmsy10', 0x2219),
+    '\\lfloor'                   : ('cmsy10', 0x62),
+    '\\ll'                       : ('cmsy10', 0xbf),
+    '\\mid'                      : ('cmsy10', 0x6a),
+    '\\mp'                       : ('cmsy10', 0xa8),
+    '\\nabla'                    : ('cmsy10', 0x72),
+    '\\nearrow'                  : ('cmsy10', 0x25),
+    '\\neg'                      : ('cmsy10', 0x3a),
+    '\\ni'                       : ('cmsy10', 0x33),
+    '\\nwarrow'                  : ('cmsy10', 0x2d),
+    '\\odot'                     : ('cmsy10', 0xaf),
+    '\\ominus'                   : ('cmsy10', 0xaa),
+    '\\oplus'                    : ('cmsy10', 0xa9),
+    '\\oslash'                   : ('cmsy10', 0xae),
+    '\\otimes'                   : ('cmsy10', 0xad),
+    '\\pm'                       : ('cmsy10', 0xa7),
+    '\\prec'                     : ('cmsy10', 0xc1),
+    '\\preceq'                   : ('cmsy10', 0xb9),
+    '\\prime'                    : ('cmsy10', 0x30),
+    '\\propto'                   : ('cmsy10', 0x2f),
+    '\\rbrace'                   : ('cmsy10', 0x67),
+    '\\rceil'                    : ('cmsy10', 0x65),
+    '\\rfloor'                   : ('cmsy10', 0x63),
+    '\\rightarrow'               : ('cmsy10', 0x21),
+    '\\searrow'                  : ('cmsy10', 0x26),
+    '\\sim'                      : ('cmsy10', 0xbb),
+    '\\simeq'                    : ('cmsy10', 0x27),
+    '\\slash'                    : ('cmsy10', 0x36),
+    '\\spadesuit'                : ('cmsy10', 0xc4),
+    '\\sqcap'                    : ('cmsy10', 0x75),
+    '\\sqcup'                    : ('cmsy10', 0x74),
+    '\\sqsubseteq'               : ('cmsy10', 0x76),
+    '\\sqsupseteq'               : ('cmsy10', 0x77),
+    '\\subset'                   : ('cmsy10', 0xbd),
+    '\\subseteq'                 : ('cmsy10', 0xb5),
+    '\\succ'                     : ('cmsy10', 0xc2),
+    '\\succeq'                   : ('cmsy10', 0xba),
+    '\\supset'                   : ('cmsy10', 0xbe),
+    '\\supseteq'                 : ('cmsy10', 0xb6),
+    '\\swarrow'                  : ('cmsy10', 0x2e),
+    '\\times'                    : ('cmsy10', 0xa3),
+    '\\to'                       : ('cmsy10', 0x21),
+    '\\top'                      : ('cmsy10', 0x3e),
+    '\\uparrow'                  : ('cmsy10', 0x22),
+    '\\updownarrow'              : ('cmsy10', 0x6c),
+    '\\uplus'                    : ('cmsy10', 0x5d),
+    '\\vdash'                    : ('cmsy10', 0x60),
+    '\\vee'                      : ('cmsy10', 0x5f),
+    '\\vert'                     : ('cmsy10', 0x6a),
+    '\\wedge'                    : ('cmsy10', 0x5e),
+    '\\wr'                       : ('cmsy10', 0x6f),
+    '\\|'                        : ('cmsy10', 0x6b),
+    '|'                          : ('cmsy10', 0x6a),
+
+    '\\_'                        : ('cmtt10', 0x5f)
+}
+
+# Automatically generated.
+
+type12uni = {
+    'aring'          : 229,
+    'quotedblright'  : 8221,
+    'V'              : 86,
+    'dollar'         : 36,
+    'four'           : 52,
+    'Yacute'         : 221,
+    'P'              : 80,
+    'underscore'     : 95,
+    'p'              : 112,
+    'Otilde'         : 213,
+    'perthousand'    : 8240,
+    'zero'           : 48,
+    'dotlessi'       : 305,
+    'Scaron'         : 352,
+    'zcaron'         : 382,
+    'egrave'         : 232,
+    'section'        : 167,
+    'Icircumflex'    : 206,
+    'ntilde'         : 241,
+    'ampersand'      : 38,
+    'dotaccent'      : 729,
+    'degree'         : 176,
+    'K'              : 75,
+    'acircumflex'    : 226,
+    'Aring'          : 197,
+    'k'              : 107,
+    'smalltilde'     : 732,
+    'Agrave'         : 192,
+    'divide'         : 247,
+    'ocircumflex'    : 244,
+    'asciitilde'     : 126,
+    'two'            : 50,
+    'E'              : 69,
+    'scaron'         : 353,
+    'F'              : 70,
+    'bracketleft'    : 91,
+    'asciicircum'    : 94,
+    'f'              : 102,
+    'ordmasculine'   : 186,
+    'mu'             : 181,
+    'paragraph'      : 182,
+    'nine'           : 57,
+    'v'              : 118,
+    'guilsinglleft'  : 8249,
+    'backslash'      : 92,
+    'six'            : 54,
+    'A'              : 65,
+    'icircumflex'    : 238,
+    'a'              : 97,
+    'ogonek'         : 731,
+    'q'              : 113,
+    'oacute'         : 243,
+    'ograve'         : 242,
+    'edieresis'      : 235,
+    'comma'          : 44,
+    'otilde'         : 245,
+    'guillemotright' : 187,
+    'ecircumflex'    : 234,
+    'greater'        : 62,
+    'uacute'         : 250,
+    'L'              : 76,
+    'bullet'         : 8226,
+    'cedilla'        : 184,
+    'ydieresis'      : 255,
+    'l'              : 108,
+    'logicalnot'     : 172,
+    'exclamdown'     : 161,
+    'endash'         : 8211,
+    'agrave'         : 224,
+    'Adieresis'      : 196,
+    'germandbls'     : 223,
+    'Odieresis'      : 214,
+    'space'          : 32,
+    'quoteright'     : 8217,
+    'ucircumflex'    : 251,
+    'G'              : 71,
+    'quoteleft'      : 8216,
+    'W'              : 87,
+    'Q'              : 81,
+    'g'              : 103,
+    'w'              : 119,
+    'question'       : 63,
+    'one'            : 49,
+    'ring'           : 730,
+    'figuredash'     : 8210,
+    'B'              : 66,
+    'iacute'         : 237,
+    'Ydieresis'      : 376,
+    'R'              : 82,
+    'b'              : 98,
+    'r'              : 114,
+    'Ccedilla'       : 199,
+    'minus'          : 8722,
+    'Lslash'         : 321,
+    'Uacute'         : 218,
+    'yacute'         : 253,
+    'Ucircumflex'    : 219,
+    'quotedbl'       : 34,
+    'onehalf'        : 189,
+    'Thorn'          : 222,
+    'M'              : 77,
+    'eight'          : 56,
+    'multiply'       : 215,
+    'grave'          : 96,
+    'Ocircumflex'    : 212,
+    'm'              : 109,
+    'Ugrave'         : 217,
+    'guilsinglright' : 8250,
+    'Ntilde'         : 209,
+    'questiondown'   : 191,
+    'Atilde'         : 195,
+    'ccedilla'       : 231,
+    'Z'              : 90,
+    'copyright'      : 169,
+    'yen'            : 165,
+    'Eacute'         : 201,
+    'H'              : 72,
+    'X'              : 88,
+    'Idieresis'      : 207,
+    'bar'            : 124,
+    'h'              : 104,
+    'x'              : 120,
+    'udieresis'      : 252,
+    'ordfeminine'    : 170,
+    'braceleft'      : 123,
+    'macron'         : 175,
+    'atilde'         : 227,
+    'Acircumflex'    : 194,
+    'Oslash'         : 216,
+    'C'              : 67,
+    'quotedblleft'   : 8220,
+    'S'              : 83,
+    'exclam'         : 33,
+    'Zcaron'         : 381,
+    'equal'          : 61,
+    's'              : 115,
+    'eth'            : 240,
+    'Egrave'         : 200,
+    'hyphen'         : 45,
+    'period'         : 46,
+    'igrave'         : 236,
+    'colon'          : 58,
+    'Ecircumflex'    : 202,
+    'trademark'      : 8482,
+    'Aacute'         : 193,
+    'cent'           : 162,
+    'lslash'         : 322,
+    'c'              : 99,
+    'N'              : 78,
+    'breve'          : 728,
+    'Oacute'         : 211,
+    'guillemotleft'  : 171,
+    'n'              : 110,
+    'idieresis'      : 239,
+    'braceright'     : 125,
+    'seven'          : 55,
+    'brokenbar'      : 166,
+    'ugrave'         : 249,
+    'periodcentered' : 183,
+    'sterling'       : 163,
+    'I'              : 73,
+    'Y'              : 89,
+    'Eth'            : 208,
+    'emdash'         : 8212,
+    'i'              : 105,
+    'daggerdbl'      : 8225,
+    'y'              : 121,
+    'plusminus'      : 177,
+    'less'           : 60,
+    'Udieresis'      : 220,
+    'D'              : 68,
+    'five'           : 53,
+    'T'              : 84,
+    'oslash'         : 248,
+    'acute'          : 180,
+    'd'              : 100,
+    'OE'             : 338,
+    'Igrave'         : 204,
+    't'              : 116,
+    'parenright'     : 41,
+    'adieresis'      : 228,
+    'quotesingle'    : 39,
+    'twodotenleader' : 8229,
+    'slash'          : 47,
+    'ellipsis'       : 8230,
+    'numbersign'     : 35,
+    'odieresis'      : 246,
+    'O'              : 79,
+    'oe'             : 339,
+    'o'              : 111,
+    'Edieresis'      : 203,
+    'plus'           : 43,
+    'dagger'         : 8224,
+    'three'          : 51,
+    'hungarumlaut'   : 733,
+    'parenleft'      : 40,
+    'fraction'       : 8260,
+    'registered'     : 174,
+    'J'              : 74,
+    'dieresis'       : 168,
+    'Ograve'         : 210,
+    'j'              : 106,
+    'z'              : 122,
+    'ae'             : 230,
+    'semicolon'      : 59,
+    'at'             : 64,
+    'Iacute'         : 205,
+    'percent'        : 37,
+    'bracketright'   : 93,
+    'AE'             : 198,
+    'asterisk'       : 42,
+    'aacute'         : 225,
+    'U'              : 85,
+    'eacute'         : 233,
+    'e'              : 101,
+    'thorn'          : 254,
+    'u'              : 117,
+}
+
+uni2type1 = {v: k for k, v in type12uni.items()}
+
+#  The script below is to sort and format the tex2uni dict
+
+## For decimal values: int(hex(v), 16)
+#  newtex = {k: hex(v) for k, v in tex2uni.items()}
+#  sd = dict(sorted(newtex.items(), key=lambda item: item[0]))
+#
+## For formatting the sorted dictionary with proper spacing
+## the value '24' comes from finding the longest string in
+## the newtex keys with len(max(newtex, key=len))
+#  for key in sd:
+#      print("{0:24} : {1: <s},".format("'" + key + "'", sd[key]))
+
+tex2uni = {
+    '#'                      : 0x23,
+    '$'                      : 0x24,
+    '%'                      : 0x25,
+    'AA'                     : 0xc5,
+    'AE'                     : 0xc6,
+    'BbbC'                   : 0x2102,
+    'BbbN'                   : 0x2115,
+    'BbbP'                   : 0x2119,
+    'BbbQ'                   : 0x211a,
+    'BbbR'                   : 0x211d,
+    'BbbZ'                   : 0x2124,
+    'Bumpeq'                 : 0x224e,
+    'Cap'                    : 0x22d2,
+    'Colon'                  : 0x2237,
+    'Cup'                    : 0x22d3,
+    'DH'                     : 0xd0,
+    'Delta'                  : 0x394,
+    'Doteq'                  : 0x2251,
+    'Downarrow'              : 0x21d3,
+    'Equiv'                  : 0x2263,
+    'Finv'                   : 0x2132,
+    'Game'                   : 0x2141,
+    'Gamma'                  : 0x393,
+    'H'                      : 0x30b,
+    'Im'                     : 0x2111,
+    'Join'                   : 0x2a1d,
+    'L'                      : 0x141,
+    'Lambda'                 : 0x39b,
+    'Ldsh'                   : 0x21b2,
+    'Leftarrow'              : 0x21d0,
+    'Leftrightarrow'         : 0x21d4,
+    'Lleftarrow'             : 0x21da,
+    'Longleftarrow'          : 0x27f8,
+    'Longleftrightarrow'     : 0x27fa,
+    'Longrightarrow'         : 0x27f9,
+    'Lsh'                    : 0x21b0,
+    'Nearrow'                : 0x21d7,
+    'Nwarrow'                : 0x21d6,
+    'O'                      : 0xd8,
+    'OE'                     : 0x152,
+    'Omega'                  : 0x3a9,
+    'P'                      : 0xb6,
+    'Phi'                    : 0x3a6,
+    'Pi'                     : 0x3a0,
+    'Psi'                    : 0x3a8,
+    'QED'                    : 0x220e,
+    'Rdsh'                   : 0x21b3,
+    'Re'                     : 0x211c,
+    'Rightarrow'             : 0x21d2,
+    'Rrightarrow'            : 0x21db,
+    'Rsh'                    : 0x21b1,
+    'S'                      : 0xa7,
+    'Searrow'                : 0x21d8,
+    'Sigma'                  : 0x3a3,
+    'Subset'                 : 0x22d0,
+    'Supset'                 : 0x22d1,
+    'Swarrow'                : 0x21d9,
+    'Theta'                  : 0x398,
+    'Thorn'                  : 0xde,
+    'Uparrow'                : 0x21d1,
+    'Updownarrow'            : 0x21d5,
+    'Upsilon'                : 0x3a5,
+    'Vdash'                  : 0x22a9,
+    'Vert'                   : 0x2016,
+    'Vvdash'                 : 0x22aa,
+    'Xi'                     : 0x39e,
+    '_'                      : 0x5f,
+    '__sqrt__'               : 0x221a,
+    'aa'                     : 0xe5,
+    'ac'                     : 0x223e,
+    'acute'                  : 0x301,
+    'acwopencirclearrow'     : 0x21ba,
+    'adots'                  : 0x22f0,
+    'ae'                     : 0xe6,
+    'aleph'                  : 0x2135,
+    'alpha'                  : 0x3b1,
+    'amalg'                  : 0x2a3f,
+    'angle'                  : 0x2220,
+    'approx'                 : 0x2248,
+    'approxeq'               : 0x224a,
+    'approxident'            : 0x224b,
+    'arceq'                  : 0x2258,
+    'ast'                    : 0x2217,
+    'asterisk'               : 0x2a,
+    'asymp'                  : 0x224d,
+    'backcong'               : 0x224c,
+    'backepsilon'            : 0x3f6,
+    'backprime'              : 0x2035,
+    'backsim'                : 0x223d,
+    'backsimeq'              : 0x22cd,
+    'backslash'              : 0x5c,
+    'bagmember'              : 0x22ff,
+    'bar'                    : 0x304,
+    'barleftarrow'           : 0x21e4,
+    'barvee'                 : 0x22bd,
+    'barwedge'               : 0x22bc,
+    'because'                : 0x2235,
+    'beta'                   : 0x3b2,
+    'beth'                   : 0x2136,
+    'between'                : 0x226c,
+    'bigcap'                 : 0x22c2,
+    'bigcirc'                : 0x25cb,
+    'bigcup'                 : 0x22c3,
+    'bigodot'                : 0x2a00,
+    'bigoplus'               : 0x2a01,
+    'bigotimes'              : 0x2a02,
+    'bigsqcup'               : 0x2a06,
+    'bigstar'                : 0x2605,
+    'bigtriangledown'        : 0x25bd,
+    'bigtriangleup'          : 0x25b3,
+    'biguplus'               : 0x2a04,
+    'bigvee'                 : 0x22c1,
+    'bigwedge'               : 0x22c0,
+    'blacksquare'            : 0x25a0,
+    'blacktriangle'          : 0x25b4,
+    'blacktriangledown'      : 0x25be,
+    'blacktriangleleft'      : 0x25c0,
+    'blacktriangleright'     : 0x25b6,
+    'bot'                    : 0x22a5,
+    'bowtie'                 : 0x22c8,
+    'boxbar'                 : 0x25eb,
+    'boxdot'                 : 0x22a1,
+    'boxminus'               : 0x229f,
+    'boxplus'                : 0x229e,
+    'boxtimes'               : 0x22a0,
+    'breve'                  : 0x306,
+    'bullet'                 : 0x2219,
+    'bumpeq'                 : 0x224f,
+    'c'                      : 0x327,
+    'candra'                 : 0x310,
+    'cap'                    : 0x2229,
+    'carriagereturn'         : 0x21b5,
+    'cdot'                   : 0x22c5,
+    'cdotp'                  : 0xb7,
+    'cdots'                  : 0x22ef,
+    'cent'                   : 0xa2,
+    'check'                  : 0x30c,
+    'checkmark'              : 0x2713,
+    'chi'                    : 0x3c7,
+    'circ'                   : 0x2218,
+    'circeq'                 : 0x2257,
+    'circlearrowleft'        : 0x21ba,
+    'circlearrowright'       : 0x21bb,
+    'circledR'               : 0xae,
+    'circledS'               : 0x24c8,
+    'circledast'             : 0x229b,
+    'circledcirc'            : 0x229a,
+    'circleddash'            : 0x229d,
+    'circumflexaccent'       : 0x302,
+    'clubsuit'               : 0x2663,
+    'clubsuitopen'           : 0x2667,
+    'colon'                  : 0x3a,
+    'coloneq'                : 0x2254,
+    'combiningacuteaccent'   : 0x301,
+    'combiningbreve'         : 0x306,
+    'combiningdiaeresis'     : 0x308,
+    'combiningdotabove'      : 0x307,
+    'combiningfourdotsabove' : 0x20dc,
+    'combininggraveaccent'   : 0x300,
+    'combiningoverline'      : 0x304,
+    'combiningrightarrowabove' : 0x20d7,
+    'combiningthreedotsabove' : 0x20db,
+    'combiningtilde'         : 0x303,
+    'complement'             : 0x2201,
+    'cong'                   : 0x2245,
+    'coprod'                 : 0x2210,
+    'copyright'              : 0xa9,
+    'cup'                    : 0x222a,
+    'cupdot'                 : 0x228d,
+    'cupleftarrow'           : 0x228c,
+    'curlyeqprec'            : 0x22de,
+    'curlyeqsucc'            : 0x22df,
+    'curlyvee'               : 0x22ce,
+    'curlywedge'             : 0x22cf,
+    'curvearrowleft'         : 0x21b6,
+    'curvearrowright'        : 0x21b7,
+    'cwopencirclearrow'      : 0x21bb,
+    'd'                      : 0x323,
+    'dag'                    : 0x2020,
+    'dagger'                 : 0x2020,
+    'daleth'                 : 0x2138,
+    'danger'                 : 0x2621,
+    'dashleftarrow'          : 0x290e,
+    'dashrightarrow'         : 0x290f,
+    'dashv'                  : 0x22a3,
+    'ddag'                   : 0x2021,
+    'ddagger'                : 0x2021,
+    'ddddot'                 : 0x20dc,
+    'dddot'                  : 0x20db,
+    'ddot'                   : 0x308,
+    'ddots'                  : 0x22f1,
+    'degree'                 : 0xb0,
+    'delta'                  : 0x3b4,
+    'dh'                     : 0xf0,
+    'diamond'                : 0x22c4,
+    'diamondsuit'            : 0x2662,
+    'digamma'                : 0x3dd,
+    'disin'                  : 0x22f2,
+    'div'                    : 0xf7,
+    'divideontimes'          : 0x22c7,
+    'dot'                    : 0x307,
+    'doteq'                  : 0x2250,
+    'doteqdot'               : 0x2251,
+    'dotminus'               : 0x2238,
+    'dotplus'                : 0x2214,
+    'dots'                   : 0x2026,
+    'dotsminusdots'          : 0x223a,
+    'doublebarwedge'         : 0x2306,
+    'downarrow'              : 0x2193,
+    'downdownarrows'         : 0x21ca,
+    'downharpoonleft'        : 0x21c3,
+    'downharpoonright'       : 0x21c2,
+    'downzigzagarrow'        : 0x21af,
+    'ell'                    : 0x2113,
+    'emdash'                 : 0x2014,
+    'emptyset'               : 0x2205,
+    'endash'                 : 0x2013,
+    'epsilon'                : 0x3b5,
+    'eqcirc'                 : 0x2256,
+    'eqcolon'                : 0x2255,
+    'eqdef'                  : 0x225d,
+    'eqgtr'                  : 0x22dd,
+    'eqless'                 : 0x22dc,
+    'eqsim'                  : 0x2242,
+    'eqslantgtr'             : 0x2a96,
+    'eqslantless'            : 0x2a95,
+    'equal'                  : 0x3d,
+    'equalparallel'          : 0x22d5,
+    'equiv'                  : 0x2261,
+    'eta'                    : 0x3b7,
+    'eth'                    : 0xf0,
+    'exists'                 : 0x2203,
+    'fallingdotseq'          : 0x2252,
+    'flat'                   : 0x266d,
+    'forall'                 : 0x2200,
+    'frakC'                  : 0x212d,
+    'frakZ'                  : 0x2128,
+    'frown'                  : 0x2322,
+    'gamma'                  : 0x3b3,
+    'geq'                    : 0x2265,
+    'geqq'                   : 0x2267,
+    'geqslant'               : 0x2a7e,
+    'gg'                     : 0x226b,
+    'ggg'                    : 0x22d9,
+    'gimel'                  : 0x2137,
+    'gnapprox'               : 0x2a8a,
+    'gneqq'                  : 0x2269,
+    'gnsim'                  : 0x22e7,
+    'grave'                  : 0x300,
+    'greater'                : 0x3e,
+    'gtrapprox'              : 0x2a86,
+    'gtrdot'                 : 0x22d7,
+    'gtreqless'              : 0x22db,
+    'gtreqqless'             : 0x2a8c,
+    'gtrless'                : 0x2277,
+    'gtrsim'                 : 0x2273,
+    'guillemotleft'          : 0xab,
+    'guillemotright'         : 0xbb,
+    'guilsinglleft'          : 0x2039,
+    'guilsinglright'         : 0x203a,
+    'hat'                    : 0x302,
+    'hbar'                   : 0x127,
+    'heartsuit'              : 0x2661,
+    'hermitmatrix'           : 0x22b9,
+    'hookleftarrow'          : 0x21a9,
+    'hookrightarrow'         : 0x21aa,
+    'hslash'                 : 0x210f,
+    'i'                      : 0x131,
+    'iiiint'                 : 0x2a0c,
+    'iiint'                  : 0x222d,
+    'iint'                   : 0x222c,
+    'imageof'                : 0x22b7,
+    'imath'                  : 0x131,
+    'in'                     : 0x2208,
+    'increment'              : 0x2206,
+    'infty'                  : 0x221e,
+    'int'                    : 0x222b,
+    'intercal'               : 0x22ba,
+    'invnot'                 : 0x2310,
+    'iota'                   : 0x3b9,
+    'isinE'                  : 0x22f9,
+    'isindot'                : 0x22f5,
+    'isinobar'               : 0x22f7,
+    'isins'                  : 0x22f4,
+    'isinvb'                 : 0x22f8,
+    'jmath'                  : 0x237,
+    'k'                      : 0x328,
+    'kappa'                  : 0x3ba,
+    'kernelcontraction'      : 0x223b,
+    'l'                      : 0x142,
+    'lambda'                 : 0x3bb,
+    'lambdabar'              : 0x19b,
+    'langle'                 : 0x27e8,
+    'lasp'                   : 0x2bd,
+    'lbrace'                 : 0x7b,
+    'lbrack'                 : 0x5b,
+    'lceil'                  : 0x2308,
+    'ldots'                  : 0x2026,
+    'leadsto'                : 0x21dd,
+    'leftarrow'              : 0x2190,
+    'leftarrowtail'          : 0x21a2,
+    'leftbrace'              : 0x7b,
+    'leftharpoonaccent'      : 0x20d0,
+    'leftharpoondown'        : 0x21bd,
+    'leftharpoonup'          : 0x21bc,
+    'leftleftarrows'         : 0x21c7,
+    'leftparen'              : 0x28,
+    'leftrightarrow'         : 0x2194,
+    'leftrightarrows'        : 0x21c6,
+    'leftrightharpoons'      : 0x21cb,
+    'leftrightsquigarrow'    : 0x21ad,
+    'leftsquigarrow'         : 0x219c,
+    'leftthreetimes'         : 0x22cb,
+    'leq'                    : 0x2264,
+    'leqq'                   : 0x2266,
+    'leqslant'               : 0x2a7d,
+    'less'                   : 0x3c,
+    'lessapprox'             : 0x2a85,
+    'lessdot'                : 0x22d6,
+    'lesseqgtr'              : 0x22da,
+    'lesseqqgtr'             : 0x2a8b,
+    'lessgtr'                : 0x2276,
+    'lesssim'                : 0x2272,
+    'lfloor'                 : 0x230a,
+    'lgroup'                 : 0x27ee,
+    'lhd'                    : 0x25c1,
+    'll'                     : 0x226a,
+    'llcorner'               : 0x231e,
+    'lll'                    : 0x22d8,
+    'lnapprox'               : 0x2a89,
+    'lneqq'                  : 0x2268,
+    'lnsim'                  : 0x22e6,
+    'longleftarrow'          : 0x27f5,
+    'longleftrightarrow'     : 0x27f7,
+    'longmapsto'             : 0x27fc,
+    'longrightarrow'         : 0x27f6,
+    'looparrowleft'          : 0x21ab,
+    'looparrowright'         : 0x21ac,
+    'lq'                     : 0x2018,
+    'lrcorner'               : 0x231f,
+    'ltimes'                 : 0x22c9,
+    'macron'                 : 0xaf,
+    'maltese'                : 0x2720,
+    'mapsdown'               : 0x21a7,
+    'mapsfrom'               : 0x21a4,
+    'mapsto'                 : 0x21a6,
+    'mapsup'                 : 0x21a5,
+    'measeq'                 : 0x225e,
+    'measuredangle'          : 0x2221,
+    'measuredrightangle'     : 0x22be,
+    'merge'                  : 0x2a55,
+    'mho'                    : 0x2127,
+    'mid'                    : 0x2223,
+    'minus'                  : 0x2212,
+    'minuscolon'             : 0x2239,
+    'models'                 : 0x22a7,
+    'mp'                     : 0x2213,
+    'mu'                     : 0x3bc,
+    'multimap'               : 0x22b8,
+    'nLeftarrow'             : 0x21cd,
+    'nLeftrightarrow'        : 0x21ce,
+    'nRightarrow'            : 0x21cf,
+    'nVDash'                 : 0x22af,
+    'nVdash'                 : 0x22ae,
+    'nabla'                  : 0x2207,
+    'napprox'                : 0x2249,
+    'natural'                : 0x266e,
+    'ncong'                  : 0x2247,
+    'ne'                     : 0x2260,
+    'nearrow'                : 0x2197,
+    'neg'                    : 0xac,
+    'neq'                    : 0x2260,
+    'nequiv'                 : 0x2262,
+    'nexists'                : 0x2204,
+    'ngeq'                   : 0x2271,
+    'ngtr'                   : 0x226f,
+    'ngtrless'               : 0x2279,
+    'ngtrsim'                : 0x2275,
+    'ni'                     : 0x220b,
+    'niobar'                 : 0x22fe,
+    'nis'                    : 0x22fc,
+    'nisd'                   : 0x22fa,
+    'nleftarrow'             : 0x219a,
+    'nleftrightarrow'        : 0x21ae,
+    'nleq'                   : 0x2270,
+    'nless'                  : 0x226e,
+    'nlessgtr'               : 0x2278,
+    'nlesssim'               : 0x2274,
+    'nmid'                   : 0x2224,
+    'not'                    : 0x338,
+    'notin'                  : 0x2209,
+    'notsmallowns'           : 0x220c,
+    'nparallel'              : 0x2226,
+    'nprec'                  : 0x2280,
+    'npreccurlyeq'           : 0x22e0,
+    'nrightarrow'            : 0x219b,
+    'nsim'                   : 0x2241,
+    'nsimeq'                 : 0x2244,
+    'nsqsubseteq'            : 0x22e2,
+    'nsqsupseteq'            : 0x22e3,
+    'nsubset'                : 0x2284,
+    'nsubseteq'              : 0x2288,
+    'nsucc'                  : 0x2281,
+    'nsucccurlyeq'           : 0x22e1,
+    'nsupset'                : 0x2285,
+    'nsupseteq'              : 0x2289,
+    'ntriangleleft'          : 0x22ea,
+    'ntrianglelefteq'        : 0x22ec,
+    'ntriangleright'         : 0x22eb,
+    'ntrianglerighteq'       : 0x22ed,
+    'nu'                     : 0x3bd,
+    'nvDash'                 : 0x22ad,
+    'nvdash'                 : 0x22ac,
+    'nwarrow'                : 0x2196,
+    'o'                      : 0xf8,
+    'obar'                   : 0x233d,
+    'ocirc'                  : 0x30a,
+    'odot'                   : 0x2299,
+    'oe'                     : 0x153,
+    'oequal'                 : 0x229c,
+    'oiiint'                 : 0x2230,
+    'oiint'                  : 0x222f,
+    'oint'                   : 0x222e,
+    'omega'                  : 0x3c9,
+    'ominus'                 : 0x2296,
+    'oplus'                  : 0x2295,
+    'origof'                 : 0x22b6,
+    'oslash'                 : 0x2298,
+    'otimes'                 : 0x2297,
+    'overarc'                : 0x311,
+    'overleftarrow'          : 0x20d6,
+    'overleftrightarrow'     : 0x20e1,
+    'parallel'               : 0x2225,
+    'partial'                : 0x2202,
+    'perp'                   : 0x27c2,
+    'perthousand'            : 0x2030,
+    'phi'                    : 0x3d5,
+    'pi'                     : 0x3c0,
+    'pitchfork'              : 0x22d4,
+    'plus'                   : 0x2b,
+    'pm'                     : 0xb1,
+    'prec'                   : 0x227a,
+    'precapprox'             : 0x2ab7,
+    'preccurlyeq'            : 0x227c,
+    'preceq'                 : 0x227c,
+    'precnapprox'            : 0x2ab9,
+    'precnsim'               : 0x22e8,
+    'precsim'                : 0x227e,
+    'prime'                  : 0x2032,
+    'prod'                   : 0x220f,
+    'propto'                 : 0x221d,
+    'prurel'                 : 0x22b0,
+    'psi'                    : 0x3c8,
+    'quad'                   : 0x2003,
+    'questeq'                : 0x225f,
+    'rangle'                 : 0x27e9,
+    'rasp'                   : 0x2bc,
+    'ratio'                  : 0x2236,
+    'rbrace'                 : 0x7d,
+    'rbrack'                 : 0x5d,
+    'rceil'                  : 0x2309,
+    'rfloor'                 : 0x230b,
+    'rgroup'                 : 0x27ef,
+    'rhd'                    : 0x25b7,
+    'rho'                    : 0x3c1,
+    'rightModels'            : 0x22ab,
+    'rightangle'             : 0x221f,
+    'rightarrow'             : 0x2192,
+    'rightarrowbar'          : 0x21e5,
+    'rightarrowtail'         : 0x21a3,
+    'rightassert'            : 0x22a6,
+    'rightbrace'             : 0x7d,
+    'rightharpoonaccent'     : 0x20d1,
+    'rightharpoondown'       : 0x21c1,
+    'rightharpoonup'         : 0x21c0,
+    'rightleftarrows'        : 0x21c4,
+    'rightleftharpoons'      : 0x21cc,
+    'rightparen'             : 0x29,
+    'rightrightarrows'       : 0x21c9,
+    'rightsquigarrow'        : 0x219d,
+    'rightthreetimes'        : 0x22cc,
+    'rightzigzagarrow'       : 0x21dd,
+    'ring'                   : 0x2da,
+    'risingdotseq'           : 0x2253,
+    'rq'                     : 0x2019,
+    'rtimes'                 : 0x22ca,
+    'scrB'                   : 0x212c,
+    'scrE'                   : 0x2130,
+    'scrF'                   : 0x2131,
+    'scrH'                   : 0x210b,
+    'scrI'                   : 0x2110,
+    'scrL'                   : 0x2112,
+    'scrM'                   : 0x2133,
+    'scrR'                   : 0x211b,
+    'scre'                   : 0x212f,
+    'scrg'                   : 0x210a,
+    'scro'                   : 0x2134,
+    'scurel'                 : 0x22b1,
+    'searrow'                : 0x2198,
+    'setminus'               : 0x2216,
+    'sharp'                  : 0x266f,
+    'sigma'                  : 0x3c3,
+    'sim'                    : 0x223c,
+    'simeq'                  : 0x2243,
+    'simneqq'                : 0x2246,
+    'sinewave'               : 0x223f,
+    'slash'                  : 0x2215,
+    'smallin'                : 0x220a,
+    'smallintclockwise'      : 0x2231,
+    'smallointctrcclockwise' : 0x2233,
+    'smallowns'              : 0x220d,
+    'smallsetminus'          : 0x2216,
+    'smallvarointclockwise'  : 0x2232,
+    'smile'                  : 0x2323,
+    'solbar'                 : 0x233f,
+    'spadesuit'              : 0x2660,
+    'spadesuitopen'          : 0x2664,
+    'sphericalangle'         : 0x2222,
+    'sqcap'                  : 0x2293,
+    'sqcup'                  : 0x2294,
+    'sqsubset'               : 0x228f,
+    'sqsubseteq'             : 0x2291,
+    'sqsubsetneq'            : 0x22e4,
+    'sqsupset'               : 0x2290,
+    'sqsupseteq'             : 0x2292,
+    'sqsupsetneq'            : 0x22e5,
+    'ss'                     : 0xdf,
+    'star'                   : 0x22c6,
+    'stareq'                 : 0x225b,
+    'sterling'               : 0xa3,
+    'subset'                 : 0x2282,
+    'subseteq'               : 0x2286,
+    'subseteqq'              : 0x2ac5,
+    'subsetneq'              : 0x228a,
+    'subsetneqq'             : 0x2acb,
+    'succ'                   : 0x227b,
+    'succapprox'             : 0x2ab8,
+    'succcurlyeq'            : 0x227d,
+    'succeq'                 : 0x227d,
+    'succnapprox'            : 0x2aba,
+    'succnsim'               : 0x22e9,
+    'succsim'                : 0x227f,
+    'sum'                    : 0x2211,
+    'supset'                 : 0x2283,
+    'supseteq'               : 0x2287,
+    'supseteqq'              : 0x2ac6,
+    'supsetneq'              : 0x228b,
+    'supsetneqq'             : 0x2acc,
+    'swarrow'                : 0x2199,
+    't'                      : 0x361,
+    'tau'                    : 0x3c4,
+    'textasciiacute'         : 0xb4,
+    'textasciicircum'        : 0x5e,
+    'textasciigrave'         : 0x60,
+    'textasciitilde'         : 0x7e,
+    'textexclamdown'         : 0xa1,
+    'textquestiondown'       : 0xbf,
+    'textquotedblleft'       : 0x201c,
+    'textquotedblright'      : 0x201d,
+    'therefore'              : 0x2234,
+    'theta'                  : 0x3b8,
+    'thickspace'             : 0x2005,
+    'thorn'                  : 0xfe,
+    'tilde'                  : 0x303,
+    'times'                  : 0xd7,
+    'to'                     : 0x2192,
+    'top'                    : 0x22a4,
+    'triangle'               : 0x25b3,
+    'triangledown'           : 0x25bf,
+    'triangleeq'             : 0x225c,
+    'triangleleft'           : 0x25c1,
+    'trianglelefteq'         : 0x22b4,
+    'triangleq'              : 0x225c,
+    'triangleright'          : 0x25b7,
+    'trianglerighteq'        : 0x22b5,
+    'turnednot'              : 0x2319,
+    'twoheaddownarrow'       : 0x21a1,
+    'twoheadleftarrow'       : 0x219e,
+    'twoheadrightarrow'      : 0x21a0,
+    'twoheaduparrow'         : 0x219f,
+    'ulcorner'               : 0x231c,
+    'underbar'               : 0x331,
+    'unlhd'                  : 0x22b4,
+    'unrhd'                  : 0x22b5,
+    'uparrow'                : 0x2191,
+    'updownarrow'            : 0x2195,
+    'updownarrowbar'         : 0x21a8,
+    'updownarrows'           : 0x21c5,
+    'upharpoonleft'          : 0x21bf,
+    'upharpoonright'         : 0x21be,
+    'uplus'                  : 0x228e,
+    'upsilon'                : 0x3c5,
+    'upuparrows'             : 0x21c8,
+    'urcorner'               : 0x231d,
+    'vDash'                  : 0x22a8,
+    'varepsilon'             : 0x3b5,
+    'varisinobar'            : 0x22f6,
+    'varisins'               : 0x22f3,
+    'varkappa'               : 0x3f0,
+    'varlrtriangle'          : 0x22bf,
+    'varniobar'              : 0x22fd,
+    'varnis'                 : 0x22fb,
+    'varnothing'             : 0x2205,
+    'varphi'                 : 0x3c6,
+    'varpi'                  : 0x3d6,
+    'varpropto'              : 0x221d,
+    'varrho'                 : 0x3f1,
+    'varsigma'               : 0x3c2,
+    'vartheta'               : 0x3d1,
+    'vartriangle'            : 0x25b5,
+    'vartriangleleft'        : 0x22b2,
+    'vartriangleright'       : 0x22b3,
+    'vdash'                  : 0x22a2,
+    'vdots'                  : 0x22ee,
+    'vec'                    : 0x20d7,
+    'vee'                    : 0x2228,
+    'veebar'                 : 0x22bb,
+    'veeeq'                  : 0x225a,
+    'vert'                   : 0x7c,
+    'wedge'                  : 0x2227,
+    'wedgeq'                 : 0x2259,
+    'widebar'                : 0x305,
+    'widehat'                : 0x302,
+    'widetilde'              : 0x303,
+    'wp'                     : 0x2118,
+    'wr'                     : 0x2240,
+    'xi'                     : 0x3be,
+    'yen'                    : 0xa5,
+    'zeta'                   : 0x3b6,
+    '{'                      : 0x7b,
+    '|'                      : 0x2016,
+    '}'                      : 0x7d,
+}
+
+# Each element is a 4-tuple of the form:
+#   src_start, src_end, dst_font, dst_start
+
+_EntryTypeIn = tuple[str, str, str, str | int]
+_EntryTypeOut = tuple[int, int, str, int]
+
+_stix_virtual_fonts: dict[str, dict[str, list[_EntryTypeIn]] | list[_EntryTypeIn]] = {
+    'bb': {
+        "rm": [
+            ("\N{DIGIT ZERO}",
+             "\N{DIGIT NINE}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO}"),
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER B}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK CAPITAL A}"),
+            ("\N{LATIN CAPITAL LETTER C}",
+             "\N{LATIN CAPITAL LETTER C}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL C}"),
+            ("\N{LATIN CAPITAL LETTER D}",
+             "\N{LATIN CAPITAL LETTER G}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK CAPITAL D}"),
+            ("\N{LATIN CAPITAL LETTER H}",
+             "\N{LATIN CAPITAL LETTER H}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL H}"),
+            ("\N{LATIN CAPITAL LETTER I}",
+             "\N{LATIN CAPITAL LETTER M}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK CAPITAL I}"),
+            ("\N{LATIN CAPITAL LETTER N}",
+             "\N{LATIN CAPITAL LETTER N}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL N}"),
+            ("\N{LATIN CAPITAL LETTER O}",
+             "\N{LATIN CAPITAL LETTER O}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK CAPITAL O}"),
+            ("\N{LATIN CAPITAL LETTER P}",
+             "\N{LATIN CAPITAL LETTER Q}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL P}"),
+            ("\N{LATIN CAPITAL LETTER R}",
+             "\N{LATIN CAPITAL LETTER R}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL R}"),
+            ("\N{LATIN CAPITAL LETTER S}",
+             "\N{LATIN CAPITAL LETTER Y}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK CAPITAL S}"),
+            ("\N{LATIN CAPITAL LETTER Z}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL Z}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK SMALL A}"),
+            ("\N{GREEK CAPITAL LETTER GAMMA}",
+             "\N{GREEK CAPITAL LETTER GAMMA}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL GAMMA}"),
+            ("\N{GREEK CAPITAL LETTER PI}",
+             "\N{GREEK CAPITAL LETTER PI}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL PI}"),
+            ("\N{GREEK CAPITAL LETTER SIGMA}",
+             "\N{GREEK CAPITAL LETTER SIGMA}",
+             "rm",
+             "\N{DOUBLE-STRUCK N-ARY SUMMATION}"),
+            ("\N{GREEK SMALL LETTER GAMMA}",
+             "\N{GREEK SMALL LETTER GAMMA}",
+             "rm",
+             "\N{DOUBLE-STRUCK SMALL GAMMA}"),
+            ("\N{GREEK SMALL LETTER PI}",
+             "\N{GREEK SMALL LETTER PI}",
+             "rm",
+             "\N{DOUBLE-STRUCK SMALL PI}"),
+        ],
+        "it": [
+            ("\N{DIGIT ZERO}",
+             "\N{DIGIT NINE}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO}"),
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER B}",
+             "it",
+             0xe154),
+            ("\N{LATIN CAPITAL LETTER C}",
+             "\N{LATIN CAPITAL LETTER C}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL C}"),
+            ("\N{LATIN CAPITAL LETTER D}",
+             "\N{LATIN CAPITAL LETTER D}",
+             "it",
+             "\N{DOUBLE-STRUCK ITALIC CAPITAL D}"),
+            ("\N{LATIN CAPITAL LETTER E}",
+             "\N{LATIN CAPITAL LETTER G}",
+             "it",
+             0xe156),
+            ("\N{LATIN CAPITAL LETTER H}",
+             "\N{LATIN CAPITAL LETTER H}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL H}"),
+            ("\N{LATIN CAPITAL LETTER I}",
+             "\N{LATIN CAPITAL LETTER M}",
+             "it",
+             0xe159),
+            ("\N{LATIN CAPITAL LETTER N}",
+             "\N{LATIN CAPITAL LETTER N}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL N}"),
+            ("\N{LATIN CAPITAL LETTER O}",
+             "\N{LATIN CAPITAL LETTER O}",
+             "it",
+             0xe15e),
+            ("\N{LATIN CAPITAL LETTER P}",
+             "\N{LATIN CAPITAL LETTER Q}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL P}"),
+            ("\N{LATIN CAPITAL LETTER R}",
+             "\N{LATIN CAPITAL LETTER R}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL R}"),
+            ("\N{LATIN CAPITAL LETTER S}",
+             "\N{LATIN CAPITAL LETTER Y}",
+             "it",
+             0xe15f),
+            ("\N{LATIN CAPITAL LETTER Z}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL Z}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER C}",
+             "it",
+             0xe166),
+            ("\N{LATIN SMALL LETTER D}",
+             "\N{LATIN SMALL LETTER E}",
+             "it",
+             "\N{DOUBLE-STRUCK ITALIC SMALL D}"),
+            ("\N{LATIN SMALL LETTER F}",
+             "\N{LATIN SMALL LETTER H}",
+             "it",
+             0xe169),
+            ("\N{LATIN SMALL LETTER I}",
+             "\N{LATIN SMALL LETTER J}",
+             "it",
+             "\N{DOUBLE-STRUCK ITALIC SMALL I}"),
+            ("\N{LATIN SMALL LETTER K}",
+             "\N{LATIN SMALL LETTER Z}",
+             "it",
+             0xe16c),
+            ("\N{GREEK CAPITAL LETTER GAMMA}",
+             "\N{GREEK CAPITAL LETTER GAMMA}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL GAMMA}"),  # \Gamma (not in beta STIX fonts)
+            ("\N{GREEK CAPITAL LETTER PI}",
+             "\N{GREEK CAPITAL LETTER PI}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL PI}"),
+            ("\N{GREEK CAPITAL LETTER SIGMA}",
+             "\N{GREEK CAPITAL LETTER SIGMA}",
+             "it",
+             "\N{DOUBLE-STRUCK N-ARY SUMMATION}"),  # \Sigma (not in beta STIX fonts)
+            ("\N{GREEK SMALL LETTER GAMMA}",
+             "\N{GREEK SMALL LETTER GAMMA}",
+             "it",
+             "\N{DOUBLE-STRUCK SMALL GAMMA}"),  # \gamma (not in beta STIX fonts)
+            ("\N{GREEK SMALL LETTER PI}",
+             "\N{GREEK SMALL LETTER PI}",
+             "it",
+             "\N{DOUBLE-STRUCK SMALL PI}"),
+        ],
+        "bf": [
+            ("\N{DIGIT ZERO}",
+             "\N{DIGIT NINE}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO}"),
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER B}",
+             "bf",
+             0xe38a),
+            ("\N{LATIN CAPITAL LETTER C}",
+             "\N{LATIN CAPITAL LETTER C}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL C}"),
+            ("\N{LATIN CAPITAL LETTER D}",
+             "\N{LATIN CAPITAL LETTER D}",
+             "bf",
+             "\N{DOUBLE-STRUCK ITALIC CAPITAL D}"),
+            ("\N{LATIN CAPITAL LETTER E}",
+             "\N{LATIN CAPITAL LETTER G}",
+             "bf",
+             0xe38d),
+            ("\N{LATIN CAPITAL LETTER H}",
+             "\N{LATIN CAPITAL LETTER H}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL H}"),
+            ("\N{LATIN CAPITAL LETTER I}",
+             "\N{LATIN CAPITAL LETTER M}",
+             "bf",
+             0xe390),
+            ("\N{LATIN CAPITAL LETTER N}",
+             "\N{LATIN CAPITAL LETTER N}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL N}"),
+            ("\N{LATIN CAPITAL LETTER O}",
+             "\N{LATIN CAPITAL LETTER O}",
+             "bf",
+             0xe395),
+            ("\N{LATIN CAPITAL LETTER P}",
+             "\N{LATIN CAPITAL LETTER Q}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL P}"),
+            ("\N{LATIN CAPITAL LETTER R}",
+             "\N{LATIN CAPITAL LETTER R}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL R}"),
+            ("\N{LATIN CAPITAL LETTER S}",
+             "\N{LATIN CAPITAL LETTER Y}",
+             "bf",
+             0xe396),
+            ("\N{LATIN CAPITAL LETTER Z}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL Z}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER C}",
+             "bf",
+             0xe39d),
+            ("\N{LATIN SMALL LETTER D}",
+             "\N{LATIN SMALL LETTER E}",
+             "bf",
+             "\N{DOUBLE-STRUCK ITALIC SMALL D}"),
+            ("\N{LATIN SMALL LETTER F}",
+             "\N{LATIN SMALL LETTER H}",
+             "bf",
+             0xe3a2),
+            ("\N{LATIN SMALL LETTER I}",
+             "\N{LATIN SMALL LETTER J}",
+             "bf",
+             "\N{DOUBLE-STRUCK ITALIC SMALL I}"),
+            ("\N{LATIN SMALL LETTER K}",
+             "\N{LATIN SMALL LETTER Z}",
+             "bf",
+             0xe3a7),
+            ("\N{GREEK CAPITAL LETTER GAMMA}",
+             "\N{GREEK CAPITAL LETTER GAMMA}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL GAMMA}"),
+            ("\N{GREEK CAPITAL LETTER PI}",
+             "\N{GREEK CAPITAL LETTER PI}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL PI}"),
+            ("\N{GREEK CAPITAL LETTER SIGMA}",
+             "\N{GREEK CAPITAL LETTER SIGMA}",
+             "bf",
+             "\N{DOUBLE-STRUCK N-ARY SUMMATION}"),
+            ("\N{GREEK SMALL LETTER GAMMA}",
+             "\N{GREEK SMALL LETTER GAMMA}",
+             "bf",
+             "\N{DOUBLE-STRUCK SMALL GAMMA}"),
+            ("\N{GREEK SMALL LETTER PI}",
+             "\N{GREEK SMALL LETTER PI}",
+             "bf",
+             "\N{DOUBLE-STRUCK SMALL PI}"),
+        ],
+    },
+    'cal': [
+        ("\N{LATIN CAPITAL LETTER A}",
+         "\N{LATIN CAPITAL LETTER Z}",
+         "it",
+         0xe22d),
+    ],
+    'frak': {
+        "rm": [
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER B}",
+             "rm",
+             "\N{MATHEMATICAL FRAKTUR CAPITAL A}"),
+            ("\N{LATIN CAPITAL LETTER C}",
+             "\N{LATIN CAPITAL LETTER C}",
+             "rm",
+             "\N{BLACK-LETTER CAPITAL C}"),
+            ("\N{LATIN CAPITAL LETTER D}",
+             "\N{LATIN CAPITAL LETTER G}",
+             "rm",
+             "\N{MATHEMATICAL FRAKTUR CAPITAL D}"),
+            ("\N{LATIN CAPITAL LETTER H}",
+             "\N{LATIN CAPITAL LETTER H}",
+             "rm",
+             "\N{BLACK-LETTER CAPITAL H}"),
+            ("\N{LATIN CAPITAL LETTER I}",
+             "\N{LATIN CAPITAL LETTER I}",
+             "rm",
+             "\N{BLACK-LETTER CAPITAL I}"),
+            ("\N{LATIN CAPITAL LETTER J}",
+             "\N{LATIN CAPITAL LETTER Q}",
+             "rm",
+             "\N{MATHEMATICAL FRAKTUR CAPITAL J}"),
+            ("\N{LATIN CAPITAL LETTER R}",
+             "\N{LATIN CAPITAL LETTER R}",
+             "rm",
+             "\N{BLACK-LETTER CAPITAL R}"),
+            ("\N{LATIN CAPITAL LETTER S}",
+             "\N{LATIN CAPITAL LETTER Y}",
+             "rm",
+             "\N{MATHEMATICAL FRAKTUR CAPITAL S}"),
+            ("\N{LATIN CAPITAL LETTER Z}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "rm",
+             "\N{BLACK-LETTER CAPITAL Z}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "rm",
+             "\N{MATHEMATICAL FRAKTUR SMALL A}"),
+            ],
+        "bf": [
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "bf",
+             "\N{MATHEMATICAL BOLD FRAKTUR CAPITAL A}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "bf",
+             "\N{MATHEMATICAL BOLD FRAKTUR SMALL A}"),
+        ],
+    },
+    'scr': [
+        ("\N{LATIN CAPITAL LETTER A}",
+         "\N{LATIN CAPITAL LETTER A}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT CAPITAL A}"),
+        ("\N{LATIN CAPITAL LETTER B}",
+         "\N{LATIN CAPITAL LETTER B}",
+         "it",
+         "\N{SCRIPT CAPITAL B}"),
+        ("\N{LATIN CAPITAL LETTER C}",
+         "\N{LATIN CAPITAL LETTER D}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT CAPITAL C}"),
+        ("\N{LATIN CAPITAL LETTER E}",
+         "\N{LATIN CAPITAL LETTER F}",
+         "it",
+         "\N{SCRIPT CAPITAL E}"),
+        ("\N{LATIN CAPITAL LETTER G}",
+         "\N{LATIN CAPITAL LETTER G}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT CAPITAL G}"),
+        ("\N{LATIN CAPITAL LETTER H}",
+         "\N{LATIN CAPITAL LETTER H}",
+         "it",
+         "\N{SCRIPT CAPITAL H}"),
+        ("\N{LATIN CAPITAL LETTER I}",
+         "\N{LATIN CAPITAL LETTER I}",
+         "it",
+         "\N{SCRIPT CAPITAL I}"),
+        ("\N{LATIN CAPITAL LETTER J}",
+         "\N{LATIN CAPITAL LETTER K}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT CAPITAL J}"),
+        ("\N{LATIN CAPITAL LETTER L}",
+         "\N{LATIN CAPITAL LETTER L}",
+         "it",
+         "\N{SCRIPT CAPITAL L}"),
+        ("\N{LATIN CAPITAL LETTER M}",
+         "\N{LATIN CAPITAL LETTER M}",
+         "it",
+         "\N{SCRIPT CAPITAL M}"),
+        ("\N{LATIN CAPITAL LETTER N}",
+         "\N{LATIN CAPITAL LETTER Q}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT CAPITAL N}"),
+        ("\N{LATIN CAPITAL LETTER R}",
+         "\N{LATIN CAPITAL LETTER R}",
+         "it",
+         "\N{SCRIPT CAPITAL R}"),
+        ("\N{LATIN CAPITAL LETTER S}",
+         "\N{LATIN CAPITAL LETTER Z}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT CAPITAL S}"),
+        ("\N{LATIN SMALL LETTER A}",
+         "\N{LATIN SMALL LETTER D}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT SMALL A}"),
+        ("\N{LATIN SMALL LETTER E}",
+         "\N{LATIN SMALL LETTER E}",
+         "it",
+         "\N{SCRIPT SMALL E}"),
+        ("\N{LATIN SMALL LETTER F}",
+         "\N{LATIN SMALL LETTER F}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT SMALL F}"),
+        ("\N{LATIN SMALL LETTER G}",
+         "\N{LATIN SMALL LETTER G}",
+         "it",
+         "\N{SCRIPT SMALL G}"),
+        ("\N{LATIN SMALL LETTER H}",
+         "\N{LATIN SMALL LETTER N}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT SMALL H}"),
+        ("\N{LATIN SMALL LETTER O}",
+         "\N{LATIN SMALL LETTER O}",
+         "it",
+         "\N{SCRIPT SMALL O}"),
+        ("\N{LATIN SMALL LETTER P}",
+         "\N{LATIN SMALL LETTER Z}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT SMALL P}"),
+    ],
+    'sf': {
+        "rm": [
+            ("\N{DIGIT ZERO}",
+             "\N{DIGIT NINE}",
+             "rm",
+             "\N{MATHEMATICAL SANS-SERIF DIGIT ZERO}"),
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "rm",
+             "\N{MATHEMATICAL SANS-SERIF CAPITAL A}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "rm",
+             "\N{MATHEMATICAL SANS-SERIF SMALL A}"),
+            ("\N{GREEK CAPITAL LETTER ALPHA}",
+             "\N{GREEK CAPITAL LETTER OMEGA}",
+             "rm",
+             0xe17d),
+            ("\N{GREEK SMALL LETTER ALPHA}",
+             "\N{GREEK SMALL LETTER OMEGA}",
+             "rm",
+             0xe196),
+            ("\N{GREEK THETA SYMBOL}",
+             "\N{GREEK THETA SYMBOL}",
+             "rm",
+             0xe1b0),
+            ("\N{GREEK PHI SYMBOL}",
+             "\N{GREEK PHI SYMBOL}",
+             "rm",
+             0xe1b1),
+            ("\N{GREEK PI SYMBOL}",
+             "\N{GREEK PI SYMBOL}",
+             "rm",
+             0xe1b3),
+            ("\N{GREEK RHO SYMBOL}",
+             "\N{GREEK RHO SYMBOL}",
+             "rm",
+             0xe1b2),
+            ("\N{GREEK LUNATE EPSILON SYMBOL}",
+             "\N{GREEK LUNATE EPSILON SYMBOL}",
+             "rm",
+             0xe1af),
+            ("\N{PARTIAL DIFFERENTIAL}",
+             "\N{PARTIAL DIFFERENTIAL}",
+             "rm",
+             0xe17c),
+        ],
+        "it": [
+            # These numerals are actually upright.  We don't actually
+            # want italic numerals ever.
+            ("\N{DIGIT ZERO}",
+             "\N{DIGIT NINE}",
+             "rm",
+             "\N{MATHEMATICAL SANS-SERIF DIGIT ZERO}"),
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "it",
+             "\N{MATHEMATICAL SANS-SERIF ITALIC CAPITAL A}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "it",
+             "\N{MATHEMATICAL SANS-SERIF ITALIC SMALL A}"),
+            ("\N{GREEK CAPITAL LETTER ALPHA}",
+             "\N{GREEK CAPITAL LETTER OMEGA}",
+             "rm",
+             0xe17d),
+            ("\N{GREEK SMALL LETTER ALPHA}",
+             "\N{GREEK SMALL LETTER OMEGA}",
+             "it",
+             0xe1d8),
+            ("\N{GREEK THETA SYMBOL}",
+             "\N{GREEK THETA SYMBOL}",
+             "it",
+             0xe1f2),
+            ("\N{GREEK PHI SYMBOL}",
+             "\N{GREEK PHI SYMBOL}",
+             "it",
+             0xe1f3),
+            ("\N{GREEK PI SYMBOL}",
+             "\N{GREEK PI SYMBOL}",
+             "it",
+             0xe1f5),
+            ("\N{GREEK RHO SYMBOL}",
+             "\N{GREEK RHO SYMBOL}",
+             "it",
+             0xe1f4),
+            ("\N{GREEK LUNATE EPSILON SYMBOL}",
+             "\N{GREEK LUNATE EPSILON SYMBOL}",
+             "it",
+             0xe1f1),
+        ],
+        "bf": [
+            ("\N{DIGIT ZERO}",
+             "\N{DIGIT NINE}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD DIGIT ZERO}"),
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD CAPITAL A}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD SMALL A}"),
+            ("\N{GREEK CAPITAL LETTER ALPHA}",
+             "\N{GREEK CAPITAL LETTER OMEGA}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD CAPITAL ALPHA}"),
+            ("\N{GREEK SMALL LETTER ALPHA}",
+             "\N{GREEK SMALL LETTER OMEGA}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA}"),
+            ("\N{GREEK THETA SYMBOL}",
+             "\N{GREEK THETA SYMBOL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD THETA SYMBOL}"),
+            ("\N{GREEK PHI SYMBOL}",
+             "\N{GREEK PHI SYMBOL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD PHI SYMBOL}"),
+            ("\N{GREEK PI SYMBOL}",
+             "\N{GREEK PI SYMBOL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD PI SYMBOL}"),
+            ("\N{GREEK KAPPA SYMBOL}",
+             "\N{GREEK KAPPA SYMBOL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD KAPPA SYMBOL}"),
+            ("\N{GREEK RHO SYMBOL}",
+             "\N{GREEK RHO SYMBOL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD RHO SYMBOL}"),
+            ("\N{GREEK LUNATE EPSILON SYMBOL}",
+             "\N{GREEK LUNATE EPSILON SYMBOL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL}"),
+            ("\N{PARTIAL DIFFERENTIAL}",
+             "\N{PARTIAL DIFFERENTIAL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL}"),
+            ("\N{NABLA}",
+             "\N{NABLA}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD NABLA}"),
+        ],
+        "bfit": [
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "bfit",
+             "\N{MATHEMATICAL BOLD ITALIC CAPITAL A}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "bfit",
+             "\N{MATHEMATICAL BOLD ITALIC SMALL A}"),
+            ("\N{GREEK CAPITAL LETTER GAMMA}",
+             "\N{GREEK CAPITAL LETTER OMEGA}",
+             "bfit",
+             "\N{MATHEMATICAL BOLD ITALIC CAPITAL GAMMA}"),
+            ("\N{GREEK SMALL LETTER ALPHA}",
+             "\N{GREEK SMALL LETTER OMEGA}",
+             "bfit",
+             "\N{MATHEMATICAL BOLD ITALIC SMALL ALPHA}"),
+        ],
+    },
+    'tt': [
+        ("\N{DIGIT ZERO}",
+         "\N{DIGIT NINE}",
+         "rm",
+         "\N{MATHEMATICAL MONOSPACE DIGIT ZERO}"),
+        ("\N{LATIN CAPITAL LETTER A}",
+         "\N{LATIN CAPITAL LETTER Z}",
+         "rm",
+         "\N{MATHEMATICAL MONOSPACE CAPITAL A}"),
+        ("\N{LATIN SMALL LETTER A}",
+         "\N{LATIN SMALL LETTER Z}",
+         "rm",
+         "\N{MATHEMATICAL MONOSPACE SMALL A}")
+    ],
+}
+
+
+@overload
+def _normalize_stix_fontcodes(d: _EntryTypeIn) -> _EntryTypeOut: ...
+
+
+@overload
+def _normalize_stix_fontcodes(d: list[_EntryTypeIn]) -> list[_EntryTypeOut]: ...
+
+
+@overload
+def _normalize_stix_fontcodes(d: dict[str, list[_EntryTypeIn] |
+                                      dict[str, list[_EntryTypeIn]]]
+                              ) -> dict[str, list[_EntryTypeOut] |
+                                        dict[str, list[_EntryTypeOut]]]: ...
+
+
+def _normalize_stix_fontcodes(d):
+    if isinstance(d, tuple):
+        return tuple(ord(x) if isinstance(x, str) and len(x) == 1 else x for x in d)
+    elif isinstance(d, list):
+        return [_normalize_stix_fontcodes(x) for x in d]
+    elif isinstance(d, dict):
+        return {k: _normalize_stix_fontcodes(v) for k, v in d.items()}
+
+
+stix_virtual_fonts: dict[str, dict[str, list[_EntryTypeOut]] | list[_EntryTypeOut]]
+stix_virtual_fonts = _normalize_stix_fontcodes(_stix_virtual_fonts)
+
+# Free redundant list now that it has been normalized
+del _stix_virtual_fonts
+
+# Fix some incorrect glyphs.
+stix_glyph_fixes = {
+    # Cap and Cup glyphs are swapped.
+    0x22d2: 0x22d3,
+    0x22d3: 0x22d2,
+}

infer_4_30_0/lib/python3.10/site-packages/matplotlib/_path.pyi

@@ -0,0 +1,9 @@
+from collections.abc import Sequence
+
+import numpy as np
+
+from .transforms import BboxBase
+
+def affine_transform(points: np.ndarray, trans: np.ndarray) -> np.ndarray: ...
+def count_bboxes_overlapping_bbox(bbox: BboxBase, bboxes: Sequence[BboxBase]) -> int: ...
+def update_path_extents(path, trans, rect, minpos, ignore): ...

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

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

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

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

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

@@ -0,0 +1,36 @@
+# This is a private module implemented in C++
+from typing import final
+
+import numpy as np
+import numpy.typing as npt
+
+@final
+class TrapezoidMapTriFinder:
+    def __init__(self, triangulation: Triangulation): ...
+    def find_many(self, x: npt.NDArray[np.float64], y: npt.NDArray[np.float64]) -> npt.NDArray[np.int_]: ...
+    def get_tree_stats(self) -> list[int | float]: ...
+    def initialize(self) -> None: ...
+    def print_tree(self) -> None: ...
+
+@final
+class TriContourGenerator:
+    def __init__(self, triangulation: Triangulation, z: npt.NDArray[np.float64]): ...
+    def create_contour(self, level: float) -> tuple[list[float], list[int]]: ...
+    def create_filled_contour(self, lower_level: float, upper_level: float) -> tuple[list[float], list[int]]: ...
+
+@final
+class Triangulation:
+    def __init__(
+        self,
+        x: npt.NDArray[np.float64],
+        y: npt.NDArray[np.float64],
+        triangles: npt.NDArray[np.int_],
+        mask: npt.NDArray[np.bool_] | tuple[()],
+        edges: npt.NDArray[np.int_] | tuple[()],
+        neighbors: npt.NDArray[np.int_] | tuple[()],
+        correct_triangle_orientation: bool,
+    ): ...
+    def calculate_plane_coefficients(self, z: npt.ArrayLike) -> npt.NDArray[np.float64]: ...
+    def get_edges(self) -> npt.NDArray[np.int_]: ...
+    def get_neighbors(self) -> npt.NDArray[np.int_]: ...
+    def set_mask(self, mask: npt.NDArray[np.bool_] | tuple[()]) -> None: ...

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

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

infer_4_30_0/lib/python3.10/site-packages/matplotlib/artist.py

@@ -0,0 +1,1855 @@
+from collections import namedtuple
+import contextlib
+from functools import cache, reduce, wraps
+import inspect
+from inspect import Signature, Parameter
+import logging
+from numbers import Number, Real
+import operator
+import re
+import warnings
+
+import numpy as np
+
+import matplotlib as mpl
+from . import _api, cbook
+from .path import Path
+from .transforms import (BboxBase, Bbox, IdentityTransform, Transform, TransformedBbox,
+                         TransformedPatchPath, TransformedPath)
+
+_log = logging.getLogger(__name__)
+
+
+def _prevent_rasterization(draw):
+    # We assume that by default artists are not allowed to rasterize (unless
+    # its draw method is explicitly decorated). If it is being drawn after a
+    # rasterized artist and it has reached a raster_depth of 0, we stop
+    # rasterization so that it does not affect the behavior of normal artist
+    # (e.g., change in dpi).
+
+    @wraps(draw)
+    def draw_wrapper(artist, renderer, *args, **kwargs):
+        if renderer._raster_depth == 0 and renderer._rasterizing:
+            # Only stop when we are not in a rasterized parent
+            # and something has been rasterized since last stop.
+            renderer.stop_rasterizing()
+            renderer._rasterizing = False
+
+        return draw(artist, renderer, *args, **kwargs)
+
+    draw_wrapper._supports_rasterization = False
+    return draw_wrapper
+
+
+def allow_rasterization(draw):
+    """
+    Decorator for Artist.draw method. Provides routines
+    that run before and after the draw call. The before and after functions
+    are useful for changing artist-dependent renderer attributes or making
+    other setup function calls, such as starting and flushing a mixed-mode
+    renderer.
+    """
+
+    @wraps(draw)
+    def draw_wrapper(artist, renderer):
+        try:
+            if artist.get_rasterized():
+                if renderer._raster_depth == 0 and not renderer._rasterizing:
+                    renderer.start_rasterizing()
+                    renderer._rasterizing = True
+                renderer._raster_depth += 1
+            else:
+                if renderer._raster_depth == 0 and renderer._rasterizing:
+                    # Only stop when we are not in a rasterized parent
+                    # and something has be rasterized since last stop
+                    renderer.stop_rasterizing()
+                    renderer._rasterizing = False
+
+            if artist.get_agg_filter() is not None:
+                renderer.start_filter()
+
+            return draw(artist, renderer)
+        finally:
+            if artist.get_agg_filter() is not None:
+                renderer.stop_filter(artist.get_agg_filter())
+            if artist.get_rasterized():
+                renderer._raster_depth -= 1
+            if (renderer._rasterizing and (fig := artist.get_figure(root=True)) and
+                    fig.suppressComposite):
+                # restart rasterizing to prevent merging
+                renderer.stop_rasterizing()
+                renderer.start_rasterizing()
+
+    draw_wrapper._supports_rasterization = True
+    return draw_wrapper
+
+
+def _finalize_rasterization(draw):
+    """
+    Decorator for Artist.draw method. Needed on the outermost artist, i.e.
+    Figure, to finish up if the render is still in rasterized mode.
+    """
+    @wraps(draw)
+    def draw_wrapper(artist, renderer, *args, **kwargs):
+        result = draw(artist, renderer, *args, **kwargs)
+        if renderer._rasterizing:
+            renderer.stop_rasterizing()
+            renderer._rasterizing = False
+        return result
+    return draw_wrapper
+
+
+def _stale_axes_callback(self, val):
+    if self.axes:
+        self.axes.stale = val
+
+
+_XYPair = namedtuple("_XYPair", "x y")
+
+
+class _Unset:
+    def __repr__(self):
+        return "<UNSET>"
+_UNSET = _Unset()
+
+
+class Artist:
+    """
+    Abstract base class for objects that render into a FigureCanvas.
+
+    Typically, all visible elements in a figure are subclasses of Artist.
+    """
+
+    zorder = 0
+
+    def __init_subclass__(cls):
+
+        # Decorate draw() method so that all artists are able to stop
+        # rastrization when necessary. If the artist's draw method is already
+        # decorated (has a `_supports_rasterization` attribute), it won't be
+        # decorated.
+
+        if not hasattr(cls.draw, "_supports_rasterization"):
+            cls.draw = _prevent_rasterization(cls.draw)
+
+        # Inject custom set() methods into the subclass with signature and
+        # docstring based on the subclasses' properties.
+
+        if not hasattr(cls.set, '_autogenerated_signature'):
+            # Don't overwrite cls.set if the subclass or one of its parents
+            # has defined a set method set itself.
+            # If there was no explicit definition, cls.set is inherited from
+            # the hierarchy of auto-generated set methods, which hold the
+            # flag _autogenerated_signature.
+            return
+
+        cls.set = lambda self, **kwargs: Artist.set(self, **kwargs)
+        cls.set.__name__ = "set"
+        cls.set.__qualname__ = f"{cls.__qualname__}.set"
+        cls._update_set_signature_and_docstring()
+
+    _PROPERTIES_EXCLUDED_FROM_SET = [
+        'navigate_mode',  # not a user-facing function
+        'figure',         # changing the figure is such a profound operation
+                          # that we don't want this in set()
+        '3d_properties',  # cannot be used as a keyword due to leading digit
+    ]
+
+    @classmethod
+    def _update_set_signature_and_docstring(cls):
+        """
+        Update the signature of the set function to list all properties
+        as keyword arguments.
+
+        Property aliases are not listed in the signature for brevity, but
+        are still accepted as keyword arguments.
+        """
+        cls.set.__signature__ = Signature(
+            [Parameter("self", Parameter.POSITIONAL_OR_KEYWORD),
+             *[Parameter(prop, Parameter.KEYWORD_ONLY, default=_UNSET)
+               for prop in ArtistInspector(cls).get_setters()
+               if prop not in Artist._PROPERTIES_EXCLUDED_FROM_SET]])
+        cls.set._autogenerated_signature = True
+
+        cls.set.__doc__ = (
+            "Set multiple properties at once.\n\n"
+            "Supported properties are\n\n"
+            + kwdoc(cls))
+
+    def __init__(self):
+        self._stale = True
+        self.stale_callback = None
+        self._axes = None
+        self._parent_figure = None
+
+        self._transform = None
+        self._transformSet = False
+        self._visible = True
+        self._animated = False
+        self._alpha = None
+        self.clipbox = None
+        self._clippath = None
+        self._clipon = True
+        self._label = ''
+        self._picker = None
+        self._rasterized = False
+        self._agg_filter = None
+        # Normally, artist classes need to be queried for mouseover info if and
+        # only if they override get_cursor_data.
+        self._mouseover = type(self).get_cursor_data != Artist.get_cursor_data
+        self._callbacks = cbook.CallbackRegistry(signals=["pchanged"])
+        try:
+            self.axes = None
+        except AttributeError:
+            # Handle self.axes as a read-only property, as in Figure.
+            pass
+        self._remove_method = None
+        self._url = None
+        self._gid = None
+        self._snap = None
+        self._sketch = mpl.rcParams['path.sketch']
+        self._path_effects = mpl.rcParams['path.effects']
+        self._sticky_edges = _XYPair([], [])
+        self._in_layout = True
+
+    def __getstate__(self):
+        d = self.__dict__.copy()
+        d['stale_callback'] = None
+        return d
+
+    def remove(self):
+        """
+        Remove the artist from the figure if possible.
+
+        The effect will not be visible until the figure is redrawn, e.g.,
+        with `.FigureCanvasBase.draw_idle`.  Call `~.axes.Axes.relim` to
+        update the Axes limits if desired.
+
+        Note: `~.axes.Axes.relim` will not see collections even if the
+        collection was added to the Axes with *autolim* = True.
+
+        Note: there is no support for removing the artist's legend entry.
+        """
+
+        # There is no method to set the callback.  Instead, the parent should
+        # set the _remove_method attribute directly.  This would be a
+        # protected attribute if Python supported that sort of thing.  The
+        # callback has one parameter, which is the child to be removed.
+        if self._remove_method is not None:
+            self._remove_method(self)
+            # clear stale callback
+            self.stale_callback = None
+            _ax_flag = False
+            if hasattr(self, 'axes') and self.axes:
+                # remove from the mouse hit list
+                self.axes._mouseover_set.discard(self)
+                self.axes.stale = True
+                self.axes = None  # decouple the artist from the Axes
+                _ax_flag = True
+
+            if (fig := self.get_figure(root=False)) is not None:
+                if not _ax_flag:
+                    fig.stale = True
+                self._parent_figure = None
+
+        else:
+            raise NotImplementedError('cannot remove artist')
+        # TODO: the fix for the collections relim problem is to move the
+        # limits calculation into the artist itself, including the property of
+        # whether or not the artist should affect the limits.  Then there will
+        # be no distinction between axes.add_line, axes.add_patch, etc.
+        # TODO: add legend support
+
+    def have_units(self):
+        """Return whether units are set on any axis."""
+        ax = self.axes
+        return ax and any(axis.have_units() for axis in ax._axis_map.values())
+
+    def convert_xunits(self, x):
+        """
+        Convert *x* using the unit type of the xaxis.
+
+        If the artist is not contained in an Axes or if the xaxis does not
+        have units, *x* itself is returned.
+        """
+        ax = getattr(self, 'axes', None)
+        if ax is None or ax.xaxis is None:
+            return x
+        return ax.xaxis.convert_units(x)
+
+    def convert_yunits(self, y):
+        """
+        Convert *y* using the unit type of the yaxis.
+
+        If the artist is not contained in an Axes or if the yaxis does not
+        have units, *y* itself is returned.
+        """
+        ax = getattr(self, 'axes', None)
+        if ax is None or ax.yaxis is None:
+            return y
+        return ax.yaxis.convert_units(y)
+
+    @property
+    def axes(self):
+        """The `~.axes.Axes` instance the artist resides in, or *None*."""
+        return self._axes
+
+    @axes.setter
+    def axes(self, new_axes):
+        if (new_axes is not None and self._axes is not None
+                and new_axes != self._axes):
+            raise ValueError("Can not reset the Axes. You are probably trying to reuse "
+                             "an artist in more than one Axes which is not supported")
+        self._axes = new_axes
+        if new_axes is not None and new_axes is not self:
+            self.stale_callback = _stale_axes_callback
+
+    @property
+    def stale(self):
+        """
+        Whether the artist is 'stale' and needs to be re-drawn for the output
+        to match the internal state of the artist.
+        """
+        return self._stale
+
+    @stale.setter
+    def stale(self, val):
+        self._stale = val
+
+        # if the artist is animated it does not take normal part in the
+        # draw stack and is not expected to be drawn as part of the normal
+        # draw loop (when not saving) so do not propagate this change
+        if self._animated:
+            return
+
+        if val and self.stale_callback is not None:
+            self.stale_callback(self, val)
+
+    def get_window_extent(self, renderer=None):
+        """
+        Get the artist's bounding box in display space.
+
+        The bounding box' width and height are nonnegative.
+
+        Subclasses should override for inclusion in the bounding box
+        "tight" calculation. Default is to return an empty bounding
+        box at 0, 0.
+
+        Be careful when using this function, the results will not update
+        if the artist window extent of the artist changes.  The extent
+        can change due to any changes in the transform stack, such as
+        changing the Axes limits, the figure size, or the canvas used
+        (as is done when saving a figure).  This can lead to unexpected
+        behavior where interactive figures will look fine on the screen,
+        but will save incorrectly.
+        """
+        return Bbox([[0, 0], [0, 0]])
+
+    def get_tightbbox(self, renderer=None):
+        """
+        Like `.Artist.get_window_extent`, but includes any clipping.
+
+        Parameters
+        ----------
+        renderer : `~matplotlib.backend_bases.RendererBase` subclass, optional
+            renderer that will be used to draw the figures (i.e.
+            ``fig.canvas.get_renderer()``)
+
+        Returns
+        -------
+        `.Bbox` or None
+            The enclosing bounding box (in figure pixel coordinates).
+            Returns None if clipping results in no intersection.
+        """
+        bbox = self.get_window_extent(renderer)
+        if self.get_clip_on():
+            clip_box = self.get_clip_box()
+            if clip_box is not None:
+                bbox = Bbox.intersection(bbox, clip_box)
+            clip_path = self.get_clip_path()
+            if clip_path is not None and bbox is not None:
+                clip_path = clip_path.get_fully_transformed_path()
+                bbox = Bbox.intersection(bbox, clip_path.get_extents())
+        return bbox
+
+    def add_callback(self, func):
+        """
+        Add a callback function that will be called whenever one of the
+        `.Artist`'s properties changes.
+
+        Parameters
+        ----------
+        func : callable
+            The callback function. It must have the signature::
+
+                def func(artist: Artist) -> Any
+
+            where *artist* is the calling `.Artist`. Return values may exist
+            but are ignored.
+
+        Returns
+        -------
+        int
+            The observer id associated with the callback. This id can be
+            used for removing the callback with `.remove_callback` later.
+
+        See Also
+        --------
+        remove_callback
+        """
+        # Wrapping func in a lambda ensures it can be connected multiple times
+        # and never gets weakref-gc'ed.
+        return self._callbacks.connect("pchanged", lambda: func(self))
+
+    def remove_callback(self, oid):
+        """
+        Remove a callback based on its observer id.
+
+        See Also
+        --------
+        add_callback
+        """
+        self._callbacks.disconnect(oid)
+
+    def pchanged(self):
+        """
+        Call all of the registered callbacks.
+
+        This function is triggered internally when a property is changed.
+
+        See Also
+        --------
+        add_callback
+        remove_callback
+        """
+        self._callbacks.process("pchanged")
+
+    def is_transform_set(self):
+        """
+        Return whether the Artist has an explicitly set transform.
+
+        This is *True* after `.set_transform` has been called.
+        """
+        return self._transformSet
+
+    def set_transform(self, t):
+        """
+        Set the artist transform.
+
+        Parameters
+        ----------
+        t : `~matplotlib.transforms.Transform`
+        """
+        self._transform = t
+        self._transformSet = True
+        self.pchanged()
+        self.stale = True
+
+    def get_transform(self):
+        """Return the `.Transform` instance used by this artist."""
+        if self._transform is None:
+            self._transform = IdentityTransform()
+        elif (not isinstance(self._transform, Transform)
+              and hasattr(self._transform, '_as_mpl_transform')):
+            self._transform = self._transform._as_mpl_transform(self.axes)
+        return self._transform
+
+    def get_children(self):
+        r"""Return a list of the child `.Artist`\s of this `.Artist`."""
+        return []
+
+    def _different_canvas(self, event):
+        """
+        Check whether an *event* occurred on a canvas other that this artist's canvas.
+
+        If this method returns True, the event definitely occurred on a different
+        canvas; if it returns False, either it occurred on the same canvas, or we may
+        not have enough information to know.
+
+        Subclasses should start their definition of `contains` as follows::
+
+            if self._different_canvas(mouseevent):
+                return False, {}
+            # subclass-specific implementation follows
+        """
+        return (getattr(event, "canvas", None) is not None
+                and (fig := self.get_figure(root=True)) is not None
+                and event.canvas is not fig.canvas)
+
+    def contains(self, mouseevent):
+        """
+        Test whether the artist contains the mouse event.
+
+        Parameters
+        ----------
+        mouseevent : `~matplotlib.backend_bases.MouseEvent`
+
+        Returns
+        -------
+        contains : bool
+            Whether any values are within the radius.
+        details : dict
+            An artist-specific dictionary of details of the event context,
+            such as which points are contained in the pick radius. See the
+            individual Artist subclasses for details.
+        """
+        _log.warning("%r needs 'contains' method", self.__class__.__name__)
+        return False, {}
+
+    def pickable(self):
+        """
+        Return whether the artist is pickable.
+
+        See Also
+        --------
+        .Artist.set_picker, .Artist.get_picker, .Artist.pick
+        """
+        return self.get_figure(root=False) is not None and self._picker is not None
+
+    def pick(self, mouseevent):
+        """
+        Process a pick event.
+
+        Each child artist will fire a pick event if *mouseevent* is over
+        the artist and the artist has picker set.
+
+        See Also
+        --------
+        .Artist.set_picker, .Artist.get_picker, .Artist.pickable
+        """
+        from .backend_bases import PickEvent  # Circular import.
+        # Pick self
+        if self.pickable():
+            picker = self.get_picker()
+            if callable(picker):
+                inside, prop = picker(self, mouseevent)
+            else:
+                inside, prop = self.contains(mouseevent)
+            if inside:
+                PickEvent("pick_event", self.get_figure(root=True).canvas,
+                          mouseevent, self, **prop)._process()
+
+        # Pick children
+        for a in self.get_children():
+            # make sure the event happened in the same Axes
+            ax = getattr(a, 'axes', None)
+            if (isinstance(a, mpl.figure.SubFigure)
+                    or mouseevent.inaxes is None or ax is None
+                    or mouseevent.inaxes == ax):
+                # we need to check if mouseevent.inaxes is None
+                # because some objects associated with an Axes (e.g., a
+                # tick label) can be outside the bounding box of the
+                # Axes and inaxes will be None
+                # also check that ax is None so that it traverse objects
+                # which do not have an axes property but children might
+                a.pick(mouseevent)
+
+    def set_picker(self, picker):
+        """
+        Define the picking behavior of the artist.
+
+        Parameters
+        ----------
+        picker : None or bool or float or callable
+            This can be one of the following:
+
+            - *None*: Picking is disabled for this artist (default).
+
+            - A boolean: If *True* then picking will be enabled and the
+              artist will fire a pick event if the mouse event is over
+              the artist.
+
+            - A float: If picker is a number it is interpreted as an
+              epsilon tolerance in points and the artist will fire
+              off an event if its data is within epsilon of the mouse
+              event.  For some artists like lines and patch collections,
+              the artist may provide additional data to the pick event
+              that is generated, e.g., the indices of the data within
+              epsilon of the pick event
+
+            - A function: If picker is callable, it is a user supplied
+              function which determines whether the artist is hit by the
+              mouse event::
+
+                hit, props = picker(artist, mouseevent)
+
+              to determine the hit test.  if the mouse event is over the
+              artist, return *hit=True* and props is a dictionary of
+              properties you want added to the PickEvent attributes.
+        """
+        self._picker = picker
+
+    def get_picker(self):
+        """
+        Return the picking behavior of the artist.
+
+        The possible values are described in `.Artist.set_picker`.
+
+        See Also
+        --------
+        .Artist.set_picker, .Artist.pickable, .Artist.pick
+        """
+        return self._picker
+
+    def get_url(self):
+        """Return the url."""
+        return self._url
+
+    def set_url(self, url):
+        """
+        Set the url for the artist.
+
+        Parameters
+        ----------
+        url : str
+        """
+        self._url = url
+
+    def get_gid(self):
+        """Return the group id."""
+        return self._gid
+
+    def set_gid(self, gid):
+        """
+        Set the (group) id for the artist.
+
+        Parameters
+        ----------
+        gid : str
+        """
+        self._gid = gid
+
+    def get_snap(self):
+        """
+        Return the snap setting.
+
+        See `.set_snap` for details.
+        """
+        if mpl.rcParams['path.snap']:
+            return self._snap
+        else:
+            return False
+
+    def set_snap(self, snap):
+        """
+        Set the snapping behavior.
+
+        Snapping aligns positions with the pixel grid, which results in
+        clearer images. For example, if a black line of 1px width was
+        defined at a position in between two pixels, the resulting image
+        would contain the interpolated value of that line in the pixel grid,
+        which would be a grey value on both adjacent pixel positions. In
+        contrast, snapping will move the line to the nearest integer pixel
+        value, so that the resulting image will really contain a 1px wide
+        black line.
+
+        Snapping is currently only supported by the Agg and MacOSX backends.
+
+        Parameters
+        ----------
+        snap : bool or None
+            Possible values:
+
+            - *True*: Snap vertices to the nearest pixel center.
+            - *False*: Do not modify vertex positions.
+            - *None*: (auto) If the path contains only rectilinear line
+              segments, round to the nearest pixel center.
+        """
+        self._snap = snap
+        self.stale = True
+
+    def get_sketch_params(self):
+        """
+        Return the sketch parameters for the artist.
+
+        Returns
+        -------
+        tuple or None
+
+            A 3-tuple with the following elements:
+
+            - *scale*: The amplitude of the wiggle perpendicular to the
+              source line.
+            - *length*: The length of the wiggle along the line.
+            - *randomness*: The scale factor by which the length is
+              shrunken or expanded.
+
+            Returns *None* if no sketch parameters were set.
+        """
+        return self._sketch
+
+    def set_sketch_params(self, scale=None, length=None, randomness=None):
+        """
+        Set the sketch parameters.
+
+        Parameters
+        ----------
+        scale : float, optional
+            The amplitude of the wiggle perpendicular to the source
+            line, in pixels.  If scale is `None`, or not provided, no
+            sketch filter will be provided.
+        length : float, optional
+             The length of the wiggle along the line, in pixels
+             (default 128.0)
+        randomness : float, optional
+            The scale factor by which the length is shrunken or
+            expanded (default 16.0)
+
+            The PGF backend uses this argument as an RNG seed and not as
+            described above. Using the same seed yields the same random shape.
+
+            .. ACCEPTS: (scale: float, length: float, randomness: float)
+        """
+        if scale is None:
+            self._sketch = None
+        else:
+            self._sketch = (scale, length or 128.0, randomness or 16.0)
+        self.stale = True
+
+    def set_path_effects(self, path_effects):
+        """
+        Set the path effects.
+
+        Parameters
+        ----------
+        path_effects : list of `.AbstractPathEffect`
+        """
+        self._path_effects = path_effects
+        self.stale = True
+
+    def get_path_effects(self):
+        return self._path_effects
+
+    def get_figure(self, root=False):
+        """
+        Return the `.Figure` or `.SubFigure` instance the artist belongs to.
+
+        Parameters
+        ----------
+        root : bool, default=False
+            If False, return the (Sub)Figure this artist is on.  If True,
+            return the root Figure for a nested tree of SubFigures.
+        """
+        if root and self._parent_figure is not None:
+            return self._parent_figure.get_figure(root=True)
+
+        return self._parent_figure
+
+    def set_figure(self, fig):
+        """
+        Set the `.Figure` or `.SubFigure` instance the artist belongs to.
+
+        Parameters
+        ----------
+        fig : `~matplotlib.figure.Figure` or `~matplotlib.figure.SubFigure`
+        """
+        # if this is a no-op just return
+        if self._parent_figure is fig:
+            return
+        # if we currently have a figure (the case of both `self.figure`
+        # and *fig* being none is taken care of above) we then user is
+        # trying to change the figure an artist is associated with which
+        # is not allowed for the same reason as adding the same instance
+        # to more than one Axes
+        if self._parent_figure is not None:
+            raise RuntimeError("Can not put single artist in "
+                               "more than one figure")
+        self._parent_figure = fig
+        if self._parent_figure and self._parent_figure is not self:
+            self.pchanged()
+        self.stale = True
+
+    figure = property(get_figure, set_figure,
+                      doc=("The (Sub)Figure that the artist is on.  For more "
+                           "control, use the `get_figure` method."))
+
+    def set_clip_box(self, clipbox):
+        """
+        Set the artist's clip `.Bbox`.
+
+        Parameters
+        ----------
+        clipbox : `~matplotlib.transforms.BboxBase` or None
+            Will typically be created from a `.TransformedBbox`. For instance,
+            ``TransformedBbox(Bbox([[0, 0], [1, 1]]), ax.transAxes)`` is the default
+            clipping for an artist added to an Axes.
+
+        """
+        _api.check_isinstance((BboxBase, None), clipbox=clipbox)
+        if clipbox != self.clipbox:
+            self.clipbox = clipbox
+            self.pchanged()
+            self.stale = True
+
+    def set_clip_path(self, path, transform=None):
+        """
+        Set the artist's clip path.
+
+        Parameters
+        ----------
+        path : `~matplotlib.patches.Patch` or `.Path` or `.TransformedPath` or None
+            The clip path. If given a `.Path`, *transform* must be provided as
+            well. If *None*, a previously set clip path is removed.
+        transform : `~matplotlib.transforms.Transform`, optional
+            Only used if *path* is a `.Path`, in which case the given `.Path`
+            is converted to a `.TransformedPath` using *transform*.
+
+        Notes
+        -----
+        For efficiency, if *path* is a `.Rectangle` this method will set the
+        clipping box to the corresponding rectangle and set the clipping path
+        to ``None``.
+
+        For technical reasons (support of `~.Artist.set`), a tuple
+        (*path*, *transform*) is also accepted as a single positional
+        parameter.
+
+        .. ACCEPTS: Patch or (Path, Transform) or None
+        """
+        from matplotlib.patches import Patch, Rectangle
+
+        success = False
+        if transform is None:
+            if isinstance(path, Rectangle):
+                self.clipbox = TransformedBbox(Bbox.unit(),
+                                               path.get_transform())
+                self._clippath = None
+                success = True
+            elif isinstance(path, Patch):
+                self._clippath = TransformedPatchPath(path)
+                success = True
+            elif isinstance(path, tuple):
+                path, transform = path
+
+        if path is None:
+            self._clippath = None
+            success = True
+        elif isinstance(path, Path):
+            self._clippath = TransformedPath(path, transform)
+            success = True
+        elif isinstance(path, TransformedPatchPath):
+            self._clippath = path
+            success = True
+        elif isinstance(path, TransformedPath):
+            self._clippath = path
+            success = True
+
+        if not success:
+            raise TypeError(
+                "Invalid arguments to set_clip_path, of type "
+                f"{type(path).__name__} and {type(transform).__name__}")
+        # This may result in the callbacks being hit twice, but guarantees they
+        # will be hit at least once.
+        self.pchanged()
+        self.stale = True
+
+    def get_alpha(self):
+        """
+        Return the alpha value used for blending - not supported on all
+        backends.
+        """
+        return self._alpha
+
+    def get_visible(self):
+        """Return the visibility."""
+        return self._visible
+
+    def get_animated(self):
+        """Return whether the artist is animated."""
+        return self._animated
+
+    def get_in_layout(self):
+        """
+        Return boolean flag, ``True`` if artist is included in layout
+        calculations.
+
+        E.g. :ref:`constrainedlayout_guide`,
+        `.Figure.tight_layout()`, and
+        ``fig.savefig(fname, bbox_inches='tight')``.
+        """
+        return self._in_layout
+
+    def _fully_clipped_to_axes(self):
+        """
+        Return a boolean flag, ``True`` if the artist is clipped to the Axes
+        and can thus be skipped in layout calculations. Requires `get_clip_on`
+        is True, one of `clip_box` or `clip_path` is set, ``clip_box.extents``
+        is equivalent to ``ax.bbox.extents`` (if set), and ``clip_path._patch``
+        is equivalent to ``ax.patch`` (if set).
+        """
+        # Note that ``clip_path.get_fully_transformed_path().get_extents()``
+        # cannot be directly compared to ``axes.bbox.extents`` because the
+        # extents may be undefined (i.e. equivalent to ``Bbox.null()``)
+        # before the associated artist is drawn, and this method is meant
+        # to determine whether ``axes.get_tightbbox()`` may bypass drawing
+        clip_box = self.get_clip_box()
+        clip_path = self.get_clip_path()
+        return (self.axes is not None
+                and self.get_clip_on()
+                and (clip_box is not None or clip_path is not None)
+                and (clip_box is None
+                     or np.all(clip_box.extents == self.axes.bbox.extents))
+                and (clip_path is None
+                     or isinstance(clip_path, TransformedPatchPath)
+                     and clip_path._patch is self.axes.patch))
+
+    def get_clip_on(self):
+        """Return whether the artist uses clipping."""
+        return self._clipon
+
+    def get_clip_box(self):
+        """Return the clipbox."""
+        return self.clipbox
+
+    def get_clip_path(self):
+        """Return the clip path."""
+        return self._clippath
+
+    def get_transformed_clip_path_and_affine(self):
+        """
+        Return the clip path with the non-affine part of its
+        transformation applied, and the remaining affine part of its
+        transformation.
+        """
+        if self._clippath is not None:
+            return self._clippath.get_transformed_path_and_affine()
+        return None, None
+
+    def set_clip_on(self, b):
+        """
+        Set whether the artist uses clipping.
+
+        When False, artists will be visible outside the Axes which
+        can lead to unexpected results.
+
+        Parameters
+        ----------
+        b : bool
+        """
+        self._clipon = b
+        # This may result in the callbacks being hit twice, but ensures they
+        # are hit at least once
+        self.pchanged()
+        self.stale = True
+
+    def _set_gc_clip(self, gc):
+        """Set the clip properly for the gc."""
+        if self._clipon:
+            if self.clipbox is not None:
+                gc.set_clip_rectangle(self.clipbox)
+            gc.set_clip_path(self._clippath)
+        else:
+            gc.set_clip_rectangle(None)
+            gc.set_clip_path(None)
+
+    def get_rasterized(self):
+        """Return whether the artist is to be rasterized."""
+        return self._rasterized
+
+    def set_rasterized(self, rasterized):
+        """
+        Force rasterized (bitmap) drawing for vector graphics output.
+
+        Rasterized drawing is not supported by all artists. If you try to
+        enable this on an artist that does not support it, the command has no
+        effect and a warning will be issued.
+
+        This setting is ignored for pixel-based output.
+
+        See also :doc:`/gallery/misc/rasterization_demo`.
+
+        Parameters
+        ----------
+        rasterized : bool
+        """
+        supports_rasterization = getattr(self.draw,
+                                         "_supports_rasterization", False)
+        if rasterized and not supports_rasterization:
+            _api.warn_external(f"Rasterization of '{self}' will be ignored")
+
+        self._rasterized = rasterized
+
+    def get_agg_filter(self):
+        """Return filter function to be used for agg filter."""
+        return self._agg_filter
+
+    def set_agg_filter(self, filter_func):
+        """
+        Set the agg filter.
+
+        Parameters
+        ----------
+        filter_func : callable
+            A filter function, which takes a (m, n, depth) float array
+            and a dpi value, and returns a (m, n, depth) array and two
+            offsets from the bottom left corner of the image
+
+            .. ACCEPTS: a filter function, which takes a (m, n, 3) float array
+                and a dpi value, and returns a (m, n, 3) array and two offsets
+                from the bottom left corner of the image
+        """
+        self._agg_filter = filter_func
+        self.stale = True
+
+    def draw(self, renderer):
+        """
+        Draw the Artist (and its children) using the given renderer.
+
+        This has no effect if the artist is not visible (`.Artist.get_visible`
+        returns False).
+
+        Parameters
+        ----------
+        renderer : `~matplotlib.backend_bases.RendererBase` subclass.
+
+        Notes
+        -----
+        This method is overridden in the Artist subclasses.
+        """
+        if not self.get_visible():
+            return
+        self.stale = False
+
+    def set_alpha(self, alpha):
+        """
+        Set the alpha value used for blending - not supported on all backends.
+
+        Parameters
+        ----------
+        alpha : float or None
+            *alpha* must be within the 0-1 range, inclusive.
+        """
+        if alpha is not None and not isinstance(alpha, Real):
+            raise TypeError(
+                f'alpha must be numeric or None, not {type(alpha)}')
+        if alpha is not None and not (0 <= alpha <= 1):
+            raise ValueError(f'alpha ({alpha}) is outside 0-1 range')
+        if alpha != self._alpha:
+            self._alpha = alpha
+            self.pchanged()
+            self.stale = True
+
+    def _set_alpha_for_array(self, alpha):
+        """
+        Set the alpha value used for blending - not supported on all backends.
+
+        Parameters
+        ----------
+        alpha : array-like or float or None
+            All values must be within the 0-1 range, inclusive.
+            Masked values and nans are not supported.
+        """
+        if isinstance(alpha, str):
+            raise TypeError("alpha must be numeric or None, not a string")
+        if not np.iterable(alpha):
+            Artist.set_alpha(self, alpha)
+            return
+        alpha = np.asarray(alpha)
+        if not (0 <= alpha.min() and alpha.max() <= 1):
+            raise ValueError('alpha must be between 0 and 1, inclusive, '
+                             f'but min is {alpha.min()}, max is {alpha.max()}')
+        self._alpha = alpha
+        self.pchanged()
+        self.stale = True
+
+    def set_visible(self, b):
+        """
+        Set the artist's visibility.
+
+        Parameters
+        ----------
+        b : bool
+        """
+        if b != self._visible:
+            self._visible = b
+            self.pchanged()
+            self.stale = True
+
+    def set_animated(self, b):
+        """
+        Set whether the artist is intended to be used in an animation.
+
+        If True, the artist is excluded from regular drawing of the figure.
+        You have to call `.Figure.draw_artist` / `.Axes.draw_artist`
+        explicitly on the artist. This approach is used to speed up animations
+        using blitting.
+
+        See also `matplotlib.animation` and
+        :ref:`blitting`.
+
+        Parameters
+        ----------
+        b : bool
+        """
+        if self._animated != b:
+            self._animated = b
+            self.pchanged()
+
+    def set_in_layout(self, in_layout):
+        """
+        Set if artist is to be included in layout calculations,
+        E.g. :ref:`constrainedlayout_guide`,
+        `.Figure.tight_layout()`, and
+        ``fig.savefig(fname, bbox_inches='tight')``.
+
+        Parameters
+        ----------
+        in_layout : bool
+        """
+        self._in_layout = in_layout
+
+    def get_label(self):
+        """Return the label used for this artist in the legend."""
+        return self._label
+
+    def set_label(self, s):
+        """
+        Set a label that will be displayed in the legend.
+
+        Parameters
+        ----------
+        s : object
+            *s* will be converted to a string by calling `str`.
+        """
+        label = str(s) if s is not None else None
+        if label != self._label:
+            self._label = label
+            self.pchanged()
+            self.stale = True
+
+    def get_zorder(self):
+        """Return the artist's zorder."""
+        return self.zorder
+
+    def set_zorder(self, level):
+        """
+        Set the zorder for the artist.  Artists with lower zorder
+        values are drawn first.
+
+        Parameters
+        ----------
+        level : float
+        """
+        if level is None:
+            level = self.__class__.zorder
+        if level != self.zorder:
+            self.zorder = level
+            self.pchanged()
+            self.stale = True
+
+    @property
+    def sticky_edges(self):
+        """
+        ``x`` and ``y`` sticky edge lists for autoscaling.
+
+        When performing autoscaling, if a data limit coincides with a value in
+        the corresponding sticky_edges list, then no margin will be added--the
+        view limit "sticks" to the edge. A typical use case is histograms,
+        where one usually expects no margin on the bottom edge (0) of the
+        histogram.
+
+        Moreover, margin expansion "bumps" against sticky edges and cannot
+        cross them.  For example, if the upper data limit is 1.0, the upper
+        view limit computed by simple margin application is 1.2, but there is a
+        sticky edge at 1.1, then the actual upper view limit will be 1.1.
+
+        This attribute cannot be assigned to; however, the ``x`` and ``y``
+        lists can be modified in place as needed.
+
+        Examples
+        --------
+        >>> artist.sticky_edges.x[:] = (xmin, xmax)
+        >>> artist.sticky_edges.y[:] = (ymin, ymax)
+
+        """
+        return self._sticky_edges
+
+    def update_from(self, other):
+        """Copy properties from *other* to *self*."""
+        self._transform = other._transform
+        self._transformSet = other._transformSet
+        self._visible = other._visible
+        self._alpha = other._alpha
+        self.clipbox = other.clipbox
+        self._clipon = other._clipon
+        self._clippath = other._clippath
+        self._label = other._label
+        self._sketch = other._sketch
+        self._path_effects = other._path_effects
+        self.sticky_edges.x[:] = other.sticky_edges.x.copy()
+        self.sticky_edges.y[:] = other.sticky_edges.y.copy()
+        self.pchanged()
+        self.stale = True
+
+    def properties(self):
+        """Return a dictionary of all the properties of the artist."""
+        return ArtistInspector(self).properties()
+
+    def _update_props(self, props, errfmt):
+        """
+        Helper for `.Artist.set` and `.Artist.update`.
+
+        *errfmt* is used to generate error messages for invalid property
+        names; it gets formatted with ``type(self)`` for "{cls}" and the
+        property name for "{prop_name}".
+        """
+        ret = []
+        with cbook._setattr_cm(self, eventson=False):
+            for k, v in props.items():
+                # Allow attributes we want to be able to update through
+                # art.update, art.set, setp.
+                if k == "axes":
+                    ret.append(setattr(self, k, v))
+                else:
+                    func = getattr(self, f"set_{k}", None)
+                    if not callable(func):
+                        raise AttributeError(
+                            errfmt.format(cls=type(self), prop_name=k),
+                            name=k)
+                    ret.append(func(v))
+        if ret:
+            self.pchanged()
+            self.stale = True
+        return ret
+
+    def update(self, props):
+        """
+        Update this artist's properties from the dict *props*.
+
+        Parameters
+        ----------
+        props : dict
+        """
+        return self._update_props(
+            props, "{cls.__name__!r} object has no property {prop_name!r}")
+
+    def _internal_update(self, kwargs):
+        """
+        Update artist properties without prenormalizing them, but generating
+        errors as if calling `set`.
+
+        The lack of prenormalization is to maintain backcompatibility.
+        """
+        return self._update_props(
+            kwargs, "{cls.__name__}.set() got an unexpected keyword argument "
+            "{prop_name!r}")
+
+    def set(self, **kwargs):
+        # docstring and signature are auto-generated via
+        # Artist._update_set_signature_and_docstring() at the end of the
+        # module.
+        return self._internal_update(cbook.normalize_kwargs(kwargs, self))
+
+    @contextlib.contextmanager
+    def _cm_set(self, **kwargs):
+        """
+        `.Artist.set` context-manager that restores original values at exit.
+        """
+        orig_vals = {k: getattr(self, f"get_{k}")() for k in kwargs}
+        try:
+            self.set(**kwargs)
+            yield
+        finally:
+            self.set(**orig_vals)
+
+    def findobj(self, match=None, include_self=True):
+        """
+        Find artist objects.
+
+        Recursively find all `.Artist` instances contained in the artist.
+
+        Parameters
+        ----------
+        match
+            A filter criterion for the matches. This can be
+
+            - *None*: Return all objects contained in artist.
+            - A function with signature ``def match(artist: Artist) -> bool``.
+              The result will only contain artists for which the function
+              returns *True*.
+            - A class instance: e.g., `.Line2D`. The result will only contain
+              artists of this class or its subclasses (``isinstance`` check).
+
+        include_self : bool
+            Include *self* in the list to be checked for a match.
+
+        Returns
+        -------
+        list of `.Artist`
+
+        """
+        if match is None:  # always return True
+            def matchfunc(x):
+                return True
+        elif isinstance(match, type) and issubclass(match, Artist):
+            def matchfunc(x):
+                return isinstance(x, match)
+        elif callable(match):
+            matchfunc = match
+        else:
+            raise ValueError('match must be None, a matplotlib.artist.Artist '
+                             'subclass, or a callable')
+
+        artists = reduce(operator.iadd,
+                         [c.findobj(matchfunc) for c in self.get_children()], [])
+        if include_self and matchfunc(self):
+            artists.append(self)
+        return artists
+
+    def get_cursor_data(self, event):
+        """
+        Return the cursor data for a given event.
+
+        .. note::
+            This method is intended to be overridden by artist subclasses.
+            As an end-user of Matplotlib you will most likely not call this
+            method yourself.
+
+        Cursor data can be used by Artists to provide additional context
+        information for a given event. The default implementation just returns
+        *None*.
+
+        Subclasses can override the method and return arbitrary data. However,
+        when doing so, they must ensure that `.format_cursor_data` can convert
+        the data to a string representation.
+
+        The only current use case is displaying the z-value of an `.AxesImage`
+        in the status bar of a plot window, while moving the mouse.
+
+        Parameters
+        ----------
+        event : `~matplotlib.backend_bases.MouseEvent`
+
+        See Also
+        --------
+        format_cursor_data
+
+        """
+        return None
+
+    def format_cursor_data(self, data):
+        """
+        Return a string representation of *data*.
+
+        .. note::
+            This method is intended to be overridden by artist subclasses.
+            As an end-user of Matplotlib you will most likely not call this
+            method yourself.
+
+        The default implementation converts ints and floats and arrays of ints
+        and floats into a comma-separated string enclosed in square brackets,
+        unless the artist has an associated colorbar, in which case scalar
+        values are formatted using the colorbar's formatter.
+
+        See Also
+        --------
+        get_cursor_data
+        """
+        if np.ndim(data) == 0 and hasattr(self, "_format_cursor_data_override"):
+            # workaround for ScalarMappable to be able to define its own
+            # format_cursor_data(). See ScalarMappable._format_cursor_data_override
+            # for details.
+            return self._format_cursor_data_override(data)
+        else:
+            try:
+                data[0]
+            except (TypeError, IndexError):
+                data = [data]
+            data_str = ', '.join(f'{item:0.3g}' for item in data
+                                 if isinstance(item, Number))
+            return "[" + data_str + "]"
+
+    def get_mouseover(self):
+        """
+        Return whether this artist is queried for custom context information
+        when the mouse cursor moves over it.
+        """
+        return self._mouseover
+
+    def set_mouseover(self, mouseover):
+        """
+        Set whether this artist is queried for custom context information when
+        the mouse cursor moves over it.
+
+        Parameters
+        ----------
+        mouseover : bool
+
+        See Also
+        --------
+        get_cursor_data
+        .ToolCursorPosition
+        .NavigationToolbar2
+        """
+        self._mouseover = bool(mouseover)
+        ax = self.axes
+        if ax:
+            if self._mouseover:
+                ax._mouseover_set.add(self)
+            else:
+                ax._mouseover_set.discard(self)
+
+    mouseover = property(get_mouseover, set_mouseover)  # backcompat.
+
+
+def _get_tightbbox_for_layout_only(obj, *args, **kwargs):
+    """
+    Matplotlib's `.Axes.get_tightbbox` and `.Axis.get_tightbbox` support a
+    *for_layout_only* kwarg; this helper tries to use the kwarg but skips it
+    when encountering third-party subclasses that do not support it.
+    """
+    try:
+        return obj.get_tightbbox(*args, **{**kwargs, "for_layout_only": True})
+    except TypeError:
+        return obj.get_tightbbox(*args, **kwargs)
+
+
+class ArtistInspector:
+    """
+    A helper class to inspect an `~matplotlib.artist.Artist` and return
+    information about its settable properties and their current values.
+    """
+
+    def __init__(self, o):
+        r"""
+        Initialize the artist inspector with an `Artist` or an iterable of
+        `Artist`\s.  If an iterable is used, we assume it is a homogeneous
+        sequence (all `Artist`\s are of the same type) and it is your
+        responsibility to make sure this is so.
+        """
+        if not isinstance(o, Artist):
+            if np.iterable(o):
+                o = list(o)
+                if len(o):
+                    o = o[0]
+
+        self.oorig = o
+        if not isinstance(o, type):
+            o = type(o)
+        self.o = o
+
+        self.aliasd = self.get_aliases()
+
+    def get_aliases(self):
+        """
+        Get a dict mapping property fullnames to sets of aliases for each alias
+        in the :class:`~matplotlib.artist.ArtistInspector`.
+
+        e.g., for lines::
+
+          {'markerfacecolor': {'mfc'},
+           'linewidth'      : {'lw'},
+          }
+        """
+        names = [name for name in dir(self.o)
+                 if name.startswith(('set_', 'get_'))
+                    and callable(getattr(self.o, name))]
+        aliases = {}
+        for name in names:
+            func = getattr(self.o, name)
+            if not self.is_alias(func):
+                continue
+            propname = re.search(f"`({name[:4]}.*)`",  # get_.*/set_.*
+                                 inspect.getdoc(func)).group(1)
+            aliases.setdefault(propname[4:], set()).add(name[4:])
+        return aliases
+
+    _get_valid_values_regex = re.compile(
+        r"\n\s*(?:\.\.\s+)?ACCEPTS:\s*((?:.|\n)*?)(?:$|(?:\n\n))"
+    )
+
+    def get_valid_values(self, attr):
+        """
+        Get the legal arguments for the setter associated with *attr*.
+
+        This is done by querying the docstring of the setter for a line that
+        begins with "ACCEPTS:" or ".. ACCEPTS:", and then by looking for a
+        numpydoc-style documentation for the setter's first argument.
+        """
+
+        name = 'set_%s' % attr
+        if not hasattr(self.o, name):
+            raise AttributeError(f'{self.o} has no function {name}')
+        func = getattr(self.o, name)
+
+        if hasattr(func, '_kwarg_doc'):
+            return func._kwarg_doc
+
+        docstring = inspect.getdoc(func)
+        if docstring is None:
+            return 'unknown'
+
+        if docstring.startswith('Alias for '):
+            return None
+
+        match = self._get_valid_values_regex.search(docstring)
+        if match is not None:
+            return re.sub("\n *", " ", match.group(1))
+
+        # Much faster than list(inspect.signature(func).parameters)[1],
+        # although barely relevant wrt. matplotlib's total import time.
+        param_name = func.__code__.co_varnames[1]
+        # We could set the presence * based on whether the parameter is a
+        # varargs (it can't be a varkwargs) but it's not really worth it.
+        match = re.search(fr"(?m)^ *\*?{param_name} : (.+)", docstring)
+        if match:
+            return match.group(1)
+
+        return 'unknown'
+
+    def _replace_path(self, source_class):
+        """
+        Changes the full path to the public API path that is used
+        in sphinx. This is needed for links to work.
+        """
+        replace_dict = {'_base._AxesBase': 'Axes',
+                        '_axes.Axes': 'Axes'}
+        for key, value in replace_dict.items():
+            source_class = source_class.replace(key, value)
+        return source_class
+
+    def get_setters(self):
+        """
+        Get the attribute strings with setters for object.
+
+        For example, for a line, return ``['markerfacecolor', 'linewidth',
+        ....]``.
+        """
+        setters = []
+        for name in dir(self.o):
+            if not name.startswith('set_'):
+                continue
+            func = getattr(self.o, name)
+            if (not callable(func)
+                    or self.number_of_parameters(func) < 2
+                    or self.is_alias(func)):
+                continue
+            setters.append(name[4:])
+        return setters
+
+    @staticmethod
+    @cache
+    def number_of_parameters(func):
+        """Return number of parameters of the callable *func*."""
+        return len(inspect.signature(func).parameters)
+
+    @staticmethod
+    @cache
+    def is_alias(method):
+        """
+        Return whether the object *method* is an alias for another method.
+        """
+
+        ds = inspect.getdoc(method)
+        if ds is None:
+            return False
+
+        return ds.startswith('Alias for ')
+
+    def aliased_name(self, s):
+        """
+        Return 'PROPNAME or alias' if *s* has an alias, else return 'PROPNAME'.
+
+        For example, for the line markerfacecolor property, which has an
+        alias, return 'markerfacecolor or mfc' and for the transform
+        property, which does not, return 'transform'.
+        """
+        aliases = ''.join(' or %s' % x for x in sorted(self.aliasd.get(s, [])))
+        return s + aliases
+
+    _NOT_LINKABLE = {
+        # A set of property setter methods that are not available in our
+        # current docs. This is a workaround used to prevent trying to link
+        # these setters which would lead to "target reference not found"
+        # warnings during doc build.
+        'matplotlib.image._ImageBase.set_alpha',
+        'matplotlib.image._ImageBase.set_array',
+        'matplotlib.image._ImageBase.set_data',
+        'matplotlib.image._ImageBase.set_filternorm',
+        'matplotlib.image._ImageBase.set_filterrad',
+        'matplotlib.image._ImageBase.set_interpolation',
+        'matplotlib.image._ImageBase.set_interpolation_stage',
+        'matplotlib.image._ImageBase.set_resample',
+        'matplotlib.text._AnnotationBase.set_annotation_clip',
+    }
+
+    def aliased_name_rest(self, s, target):
+        """
+        Return 'PROPNAME or alias' if *s* has an alias, else return 'PROPNAME',
+        formatted for reST.
+
+        For example, for the line markerfacecolor property, which has an
+        alias, return 'markerfacecolor or mfc' and for the transform
+        property, which does not, return 'transform'.
+        """
+        # workaround to prevent "reference target not found"
+        if target in self._NOT_LINKABLE:
+            return f'``{s}``'
+
+        aliases = ''.join(
+            f' or :meth:`{a} <{target}>`' for a in sorted(self.aliasd.get(s, [])))
+        return f':meth:`{s} <{target}>`{aliases}'
+
+    def pprint_setters(self, prop=None, leadingspace=2):
+        """
+        If *prop* is *None*, return a list of strings of all settable
+        properties and their valid values.
+
+        If *prop* is not *None*, it is a valid property name and that
+        property will be returned as a string of property : valid
+        values.
+        """
+        if leadingspace:
+            pad = ' ' * leadingspace
+        else:
+            pad = ''
+        if prop is not None:
+            accepts = self.get_valid_values(prop)
+            return f'{pad}{prop}: {accepts}'
+
+        lines = []
+        for prop in sorted(self.get_setters()):
+            accepts = self.get_valid_values(prop)
+            name = self.aliased_name(prop)
+            lines.append(f'{pad}{name}: {accepts}')
+        return lines
+
+    def pprint_setters_rest(self, prop=None, leadingspace=4):
+        """
+        If *prop* is *None*, return a list of reST-formatted strings of all
+        settable properties and their valid values.
+
+        If *prop* is not *None*, it is a valid property name and that
+        property will be returned as a string of "property : valid"
+        values.
+        """
+        if leadingspace:
+            pad = ' ' * leadingspace
+        else:
+            pad = ''
+        if prop is not None:
+            accepts = self.get_valid_values(prop)
+            return f'{pad}{prop}: {accepts}'
+
+        prop_and_qualnames = []
+        for prop in sorted(self.get_setters()):
+            # Find the parent method which actually provides the docstring.
+            for cls in self.o.__mro__:
+                method = getattr(cls, f"set_{prop}", None)
+                if method and method.__doc__ is not None:
+                    break
+            else:  # No docstring available.
+                method = getattr(self.o, f"set_{prop}")
+            prop_and_qualnames.append(
+                (prop, f"{method.__module__}.{method.__qualname__}"))
+
+        names = [self.aliased_name_rest(prop, target)
+                 .replace('_base._AxesBase', 'Axes')
+                 .replace('_axes.Axes', 'Axes')
+                 for prop, target in prop_and_qualnames]
+        accepts = [self.get_valid_values(prop)
+                   for prop, _ in prop_and_qualnames]
+
+        col0_len = max(len(n) for n in names)
+        col1_len = max(len(a) for a in accepts)
+        table_formatstr = pad + '   ' + '=' * col0_len + '   ' + '=' * col1_len
+
+        return [
+            '',
+            pad + '.. table::',
+            pad + '   :class: property-table',
+            '',
+            table_formatstr,
+            pad + '   ' + 'Property'.ljust(col0_len)
+            + '   ' + 'Description'.ljust(col1_len),
+            table_formatstr,
+            *[pad + '   ' + n.ljust(col0_len) + '   ' + a.ljust(col1_len)
+              for n, a in zip(names, accepts)],
+            table_formatstr,
+            '',
+        ]
+
+    def properties(self):
+        """Return a dictionary mapping property name -> value."""
+        o = self.oorig
+        getters = [name for name in dir(o)
+                   if name.startswith('get_') and callable(getattr(o, name))]
+        getters.sort()
+        d = {}
+        for name in getters:
+            func = getattr(o, name)
+            if self.is_alias(func):
+                continue
+            try:
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore')
+                    val = func()
+            except Exception:
+                continue
+            else:
+                d[name[4:]] = val
+        return d
+
+    def pprint_getters(self):
+        """Return the getters and actual values as list of strings."""
+        lines = []
+        for name, val in sorted(self.properties().items()):
+            if getattr(val, 'shape', ()) != () and len(val) > 6:
+                s = str(val[:6]) + '...'
+            else:
+                s = str(val)
+            s = s.replace('\n', ' ')
+            if len(s) > 50:
+                s = s[:50] + '...'
+            name = self.aliased_name(name)
+            lines.append(f'    {name} = {s}')
+        return lines
+
+
+def getp(obj, property=None):
+    """
+    Return the value of an `.Artist`'s *property*, or print all of them.
+
+    Parameters
+    ----------
+    obj : `~matplotlib.artist.Artist`
+        The queried artist; e.g., a `.Line2D`, a `.Text`, or an `~.axes.Axes`.
+
+    property : str or None, default: None
+        If *property* is 'somename', this function returns
+        ``obj.get_somename()``.
+
+        If it's None (or unset), it *prints* all gettable properties from
+        *obj*.  Many properties have aliases for shorter typing, e.g. 'lw' is
+        an alias for 'linewidth'.  In the output, aliases and full property
+        names will be listed as:
+
+          property or alias = value
+
+        e.g.:
+
+          linewidth or lw = 2
+
+    See Also
+    --------
+    setp
+    """
+    if property is None:
+        insp = ArtistInspector(obj)
+        ret = insp.pprint_getters()
+        print('\n'.join(ret))
+        return
+    return getattr(obj, 'get_' + property)()
+
+# alias
+get = getp
+
+
+def setp(obj, *args, file=None, **kwargs):
+    """
+    Set one or more properties on an `.Artist`, or list allowed values.
+
+    Parameters
+    ----------
+    obj : `~matplotlib.artist.Artist` or list of `.Artist`
+        The artist(s) whose properties are being set or queried.  When setting
+        properties, all artists are affected; when querying the allowed values,
+        only the first instance in the sequence is queried.
+
+        For example, two lines can be made thicker and red with a single call:
+
+        >>> x = arange(0, 1, 0.01)
+        >>> lines = plot(x, sin(2*pi*x), x, sin(4*pi*x))
+        >>> setp(lines, linewidth=2, color='r')
+
+    file : file-like, default: `sys.stdout`
+        Where `setp` writes its output when asked to list allowed values.
+
+        >>> with open('output.log') as file:
+        ...     setp(line, file=file)
+
+        The default, ``None``, means `sys.stdout`.
+
+    *args, **kwargs
+        The properties to set.  The following combinations are supported:
+
+        - Set the linestyle of a line to be dashed:
+
+          >>> line, = plot([1, 2, 3])
+          >>> setp(line, linestyle='--')
+
+        - Set multiple properties at once:
+
+          >>> setp(line, linewidth=2, color='r')
+
+        - List allowed values for a line's linestyle:
+
+          >>> setp(line, 'linestyle')
+          linestyle: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
+
+        - List all properties that can be set, and their allowed values:
+
+          >>> setp(line)
+          agg_filter: a filter function, ...
+          [long output listing omitted]
+
+        `setp` also supports MATLAB style string/value pairs.  For example, the
+        following are equivalent:
+
+        >>> setp(lines, 'linewidth', 2, 'color', 'r')  # MATLAB style
+        >>> setp(lines, linewidth=2, color='r')        # Python style
+
+    See Also
+    --------
+    getp
+    """
+
+    if isinstance(obj, Artist):
+        objs = [obj]
+    else:
+        objs = list(cbook.flatten(obj))
+
+    if not objs:
+        return
+
+    insp = ArtistInspector(objs[0])
+
+    if not kwargs and len(args) < 2:
+        if args:
+            print(insp.pprint_setters(prop=args[0]), file=file)
+        else:
+            print('\n'.join(insp.pprint_setters()), file=file)
+        return
+
+    if len(args) % 2:
+        raise ValueError('The set args must be string, value pairs')
+
+    funcvals = dict(zip(args[::2], args[1::2]))
+    ret = [o.update(funcvals) for o in objs] + [o.set(**kwargs) for o in objs]
+    return list(cbook.flatten(ret))
+
+
+def kwdoc(artist):
+    r"""
+    Inspect an `~matplotlib.artist.Artist` class (using `.ArtistInspector`) and
+    return information about its settable properties and their current values.
+
+    Parameters
+    ----------
+    artist : `~matplotlib.artist.Artist` or an iterable of `Artist`\s
+
+    Returns
+    -------
+    str
+        The settable properties of *artist*, as plain text if
+        :rc:`docstring.hardcopy` is False and as a rst table (intended for
+        use in Sphinx) if it is True.
+    """
+    ai = ArtistInspector(artist)
+    return ('\n'.join(ai.pprint_setters_rest(leadingspace=4))
+            if mpl.rcParams['docstring.hardcopy'] else
+            'Properties:\n' + '\n'.join(ai.pprint_setters(leadingspace=4)))
+
+# We defer this to the end of them module, because it needs ArtistInspector
+# to be defined.
+Artist._update_set_signature_and_docstring()

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

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

infer_4_30_0/lib/python3.10/site-packages/matplotlib/backend_bases.pyi

@@ -0,0 +1,482 @@
+from enum import Enum, IntEnum
+import os
+from matplotlib import (
+    cbook,
+    transforms,
+    widgets,
+    _api,
+)
+from matplotlib.artist import Artist
+from matplotlib.axes import Axes
+from matplotlib.backend_managers import ToolManager
+from matplotlib.backend_tools import Cursors, ToolBase
+from matplotlib.colorbar import Colorbar
+from matplotlib.figure import Figure
+from matplotlib.font_manager import FontProperties
+from matplotlib.path import Path
+from matplotlib.texmanager import TexManager
+from matplotlib.text import Text
+from matplotlib.transforms import Bbox, BboxBase, Transform, TransformedPath
+
+from collections.abc import Callable, Iterable, Sequence
+from typing import Any, IO, Literal, NamedTuple, TypeVar
+from numpy.typing import ArrayLike
+from .typing import ColorType, LineStyleType, CapStyleType, JoinStyleType
+
+def register_backend(
+    format: str, backend: str | type[FigureCanvasBase], description: str | None = ...
+) -> None: ...
+def get_registered_canvas_class(format: str) -> type[FigureCanvasBase]: ...
+
+class RendererBase:
+    def __init__(self) -> None: ...
+    def open_group(self, s: str, gid: str | None = ...) -> None: ...
+    def close_group(self, s: str) -> None: ...
+    def draw_path(
+        self,
+        gc: GraphicsContextBase,
+        path: Path,
+        transform: Transform,
+        rgbFace: ColorType | None = ...,
+    ) -> None: ...
+    def draw_markers(
+        self,
+        gc: GraphicsContextBase,
+        marker_path: Path,
+        marker_trans: Transform,
+        path: Path,
+        trans: Transform,
+        rgbFace: ColorType | None = ...,
+    ) -> None: ...
+    def draw_path_collection(
+        self,
+        gc: GraphicsContextBase,
+        master_transform: Transform,
+        paths: Sequence[Path],
+        all_transforms: Sequence[ArrayLike],
+        offsets: ArrayLike | Sequence[ArrayLike],
+        offset_trans: Transform,
+        facecolors: ColorType | Sequence[ColorType],
+        edgecolors: ColorType | Sequence[ColorType],
+        linewidths: float | Sequence[float],
+        linestyles: LineStyleType | Sequence[LineStyleType],
+        antialiaseds: bool | Sequence[bool],
+        urls: str | Sequence[str],
+        offset_position: Any,
+    ) -> None: ...
+    def draw_quad_mesh(
+        self,
+        gc: GraphicsContextBase,
+        master_transform: Transform,
+        meshWidth,
+        meshHeight,
+        coordinates: ArrayLike,
+        offsets: ArrayLike | Sequence[ArrayLike],
+        offsetTrans: Transform,
+        facecolors: Sequence[ColorType],
+        antialiased: bool,
+        edgecolors: Sequence[ColorType] | ColorType | None,
+    ) -> None: ...
+    def draw_gouraud_triangles(
+        self,
+        gc: GraphicsContextBase,
+        triangles_array: ArrayLike,
+        colors_array: ArrayLike,
+        transform: Transform,
+    ) -> None: ...
+    def get_image_magnification(self) -> float: ...
+    def draw_image(
+        self,
+        gc: GraphicsContextBase,
+        x: float,
+        y: float,
+        im: ArrayLike,
+        transform: transforms.Affine2DBase | None = ...,
+    ) -> None: ...
+    def option_image_nocomposite(self) -> bool: ...
+    def option_scale_image(self) -> bool: ...
+    def draw_tex(
+        self,
+        gc: GraphicsContextBase,
+        x: float,
+        y: float,
+        s: str,
+        prop: FontProperties,
+        angle: float,
+        *,
+        mtext: Text | None = ...
+    ) -> None: ...
+    def draw_text(
+        self,
+        gc: GraphicsContextBase,
+        x: float,
+        y: float,
+        s: str,
+        prop: FontProperties,
+        angle: float,
+        ismath: bool | Literal["TeX"] = ...,
+        mtext: Text | None = ...,
+    ) -> None: ...
+    def get_text_width_height_descent(
+        self, s: str, prop: FontProperties, ismath: bool | Literal["TeX"]
+    ) -> tuple[float, float, float]: ...
+    def flipy(self) -> bool: ...
+    def get_canvas_width_height(self) -> tuple[float, float]: ...
+    def get_texmanager(self) -> TexManager: ...
+    def new_gc(self) -> GraphicsContextBase: ...
+    def points_to_pixels(self, points: ArrayLike) -> ArrayLike: ...
+    def start_rasterizing(self) -> None: ...
+    def stop_rasterizing(self) -> None: ...
+    def start_filter(self) -> None: ...
+    def stop_filter(self, filter_func) -> None: ...
+
+class GraphicsContextBase:
+    def __init__(self) -> None: ...
+    def copy_properties(self, gc: GraphicsContextBase) -> None: ...
+    def restore(self) -> None: ...
+    def get_alpha(self) -> float: ...
+    def get_antialiased(self) -> int: ...
+    def get_capstyle(self) -> Literal["butt", "projecting", "round"]: ...
+    def get_clip_rectangle(self) -> Bbox | None: ...
+    def get_clip_path(
+        self,
+    ) -> tuple[TransformedPath, Transform] | tuple[None, None]: ...
+    def get_dashes(self) -> tuple[float, ArrayLike | None]: ...
+    def get_forced_alpha(self) -> bool: ...
+    def get_joinstyle(self) -> Literal["miter", "round", "bevel"]: ...
+    def get_linewidth(self) -> float: ...
+    def get_rgb(self) -> tuple[float, float, float, float]: ...
+    def get_url(self) -> str | None: ...
+    def get_gid(self) -> int | None: ...
+    def get_snap(self) -> bool | None: ...
+    def set_alpha(self, alpha: float) -> None: ...
+    def set_antialiased(self, b: bool) -> None: ...
+    def set_capstyle(self, cs: CapStyleType) -> None: ...
+    def set_clip_rectangle(self, rectangle: Bbox | None) -> None: ...
+    def set_clip_path(self, path: TransformedPath | None) -> None: ...
+    def set_dashes(self, dash_offset: float, dash_list: ArrayLike | None) -> None: ...
+    def set_foreground(self, fg: ColorType, isRGBA: bool = ...) -> None: ...
+    def set_joinstyle(self, js: JoinStyleType) -> None: ...
+    def set_linewidth(self, w: float) -> None: ...
+    def set_url(self, url: str | None) -> None: ...
+    def set_gid(self, id: int | None) -> None: ...
+    def set_snap(self, snap: bool | None) -> None: ...
+    def set_hatch(self, hatch: str | None) -> None: ...
+    def get_hatch(self) -> str | None: ...
+    def get_hatch_path(self, density: float = ...) -> Path: ...
+    def get_hatch_color(self) -> ColorType: ...
+    def set_hatch_color(self, hatch_color: ColorType) -> None: ...
+    def get_hatch_linewidth(self) -> float: ...
+    def set_hatch_linewidth(self, hatch_linewidth: float) -> 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: ...
+
+class TimerBase:
+    callbacks: list[tuple[Callable, tuple, dict[str, Any]]]
+    def __init__(
+        self,
+        interval: int | None = ...,
+        callbacks: list[tuple[Callable, tuple, dict[str, Any]]] | None = ...,
+    ) -> None: ...
+    def __del__(self) -> None: ...
+    def start(self, interval: int | None = ...) -> None: ...
+    def stop(self) -> None: ...
+    @property
+    def interval(self) -> int: ...
+    @interval.setter
+    def interval(self, interval: int) -> None: ...
+    @property
+    def single_shot(self) -> bool: ...
+    @single_shot.setter
+    def single_shot(self, ss: bool) -> None: ...
+    def add_callback(self, func: Callable, *args, **kwargs) -> Callable: ...
+    def remove_callback(self, func: Callable, *args, **kwargs) -> None: ...
+
+class Event:
+    name: str
+    canvas: FigureCanvasBase
+    guiEvent: Any
+    def __init__(
+        self, name: str, canvas: FigureCanvasBase, guiEvent: Any | None = ...
+    ) -> None: ...
+
+class DrawEvent(Event):
+    renderer: RendererBase
+    def __init__(
+        self, name: str, canvas: FigureCanvasBase, renderer: RendererBase
+    ) -> None: ...
+
+class ResizeEvent(Event):
+    width: int
+    height: int
+    def __init__(self, name: str, canvas: FigureCanvasBase) -> None: ...
+
+class CloseEvent(Event): ...
+
+class LocationEvent(Event):
+    x: int
+    y: int
+    inaxes: Axes | None
+    xdata: float | None
+    ydata: float | None
+    def __init__(
+        self,
+        name: str,
+        canvas: FigureCanvasBase,
+        x: int,
+        y: int,
+        guiEvent: Any | None = ...,
+        *,
+        modifiers: Iterable[str] | None = ...,
+    ) -> None: ...
+
+class MouseButton(IntEnum):
+    LEFT = 1
+    MIDDLE = 2
+    RIGHT = 3
+    BACK = 8
+    FORWARD = 9
+
+class MouseEvent(LocationEvent):
+    button: MouseButton | Literal["up", "down"] | None
+    key: str | None
+    step: float
+    dblclick: bool
+    def __init__(
+        self,
+        name: str,
+        canvas: FigureCanvasBase,
+        x: int,
+        y: int,
+        button: MouseButton | Literal["up", "down"] | None = ...,
+        key: str | None = ...,
+        step: float = ...,
+        dblclick: bool = ...,
+        guiEvent: Any | None = ...,
+        *,
+        buttons: Iterable[MouseButton] | None = ...,
+        modifiers: Iterable[str] | None = ...,
+    ) -> None: ...
+
+class PickEvent(Event):
+    mouseevent: MouseEvent
+    artist: Artist
+    def __init__(
+        self,
+        name: str,
+        canvas: FigureCanvasBase,
+        mouseevent: MouseEvent,
+        artist: Artist,
+        guiEvent: Any | None = ...,
+        **kwargs
+    ) -> None: ...
+
+class KeyEvent(LocationEvent):
+    key: str | None
+    def __init__(
+        self,
+        name: str,
+        canvas: FigureCanvasBase,
+        key: str | None,
+        x: int = ...,
+        y: int = ...,
+        guiEvent: Any | None = ...,
+    ) -> None: ...
+
+class FigureCanvasBase:
+    required_interactive_framework: str | None
+
+    @_api.classproperty
+    def manager_class(cls) -> type[FigureManagerBase]: ...
+    events: list[str]
+    fixed_dpi: None | float
+    filetypes: dict[str, str]
+
+    @_api.classproperty
+    def supports_blit(cls) -> bool: ...
+
+    figure: Figure
+    manager: None | FigureManagerBase
+    widgetlock: widgets.LockDraw
+    mouse_grabber: None | Axes
+    toolbar: None | NavigationToolbar2
+    def __init__(self, figure: Figure | None = ...) -> None: ...
+    @property
+    def callbacks(self) -> cbook.CallbackRegistry: ...
+    @property
+    def button_pick_id(self) -> int: ...
+    @property
+    def scroll_pick_id(self) -> int: ...
+    @classmethod
+    def new_manager(cls, figure: Figure, num: int | str) -> FigureManagerBase: ...
+    def is_saving(self) -> bool: ...
+    def blit(self, bbox: BboxBase | None = ...) -> None: ...
+    def inaxes(self, xy: tuple[float, float]) -> Axes | None: ...
+    def grab_mouse(self, ax: Axes) -> None: ...
+    def release_mouse(self, ax: Axes) -> None: ...
+    def set_cursor(self, cursor: Cursors) -> None: ...
+    def draw(self, *args, **kwargs) -> None: ...
+    def draw_idle(self, *args, **kwargs) -> None: ...
+    @property
+    def device_pixel_ratio(self) -> float: ...
+    def get_width_height(self, *, physical: bool = ...) -> tuple[int, int]: ...
+    @classmethod
+    def get_supported_filetypes(cls) -> dict[str, str]: ...
+    @classmethod
+    def get_supported_filetypes_grouped(cls) -> dict[str, list[str]]: ...
+    def print_figure(
+        self,
+        filename: str | os.PathLike | IO,
+        dpi: float | None = ...,
+        facecolor: ColorType | Literal["auto"] | None = ...,
+        edgecolor: ColorType | Literal["auto"] | None = ...,
+        orientation: str = ...,
+        format: str | None = ...,
+        *,
+        bbox_inches: Literal["tight"] | Bbox | None = ...,
+        pad_inches: float | None = ...,
+        bbox_extra_artists: list[Artist] | None = ...,
+        backend: str | None = ...,
+        **kwargs
+    ) -> Any: ...
+    @classmethod
+    def get_default_filetype(cls) -> str: ...
+    def get_default_filename(self) -> str: ...
+    _T = TypeVar("_T", bound=FigureCanvasBase)
+    def mpl_connect(self, s: str, func: Callable[[Event], Any]) -> int: ...
+    def mpl_disconnect(self, cid: int) -> None: ...
+    def new_timer(
+        self,
+        interval: int | None = ...,
+        callbacks: list[tuple[Callable, tuple, dict[str, Any]]] | None = ...,
+    ) -> TimerBase: ...
+    def flush_events(self) -> None: ...
+    def start_event_loop(self, timeout: float = ...) -> None: ...
+    def stop_event_loop(self) -> None: ...
+
+def key_press_handler(
+    event: KeyEvent,
+    canvas: FigureCanvasBase | None = ...,
+    toolbar: NavigationToolbar2 | None = ...,
+) -> None: ...
+def button_press_handler(
+    event: MouseEvent,
+    canvas: FigureCanvasBase | None = ...,
+    toolbar: NavigationToolbar2 | None = ...,
+) -> None: ...
+
+class NonGuiException(Exception): ...
+
+class FigureManagerBase:
+    canvas: FigureCanvasBase
+    num: int | str
+    key_press_handler_id: int | None
+    button_press_handler_id: int | None
+    toolmanager: ToolManager | None
+    toolbar: NavigationToolbar2 | ToolContainerBase | None
+    def __init__(self, canvas: FigureCanvasBase, num: int | str) -> None: ...
+    @classmethod
+    def create_with_canvas(
+        cls, canvas_class: type[FigureCanvasBase], figure: Figure, num: int | str
+    ) -> FigureManagerBase: ...
+    @classmethod
+    def start_main_loop(cls) -> None: ...
+    @classmethod
+    def pyplot_show(cls, *, block: bool | None = ...) -> None: ...
+    def show(self) -> None: ...
+    def destroy(self) -> None: ...
+    def full_screen_toggle(self) -> None: ...
+    def resize(self, w: int, h: int) -> None: ...
+    def get_window_title(self) -> str: ...
+    def set_window_title(self, title: str) -> None: ...
+
+cursors = Cursors
+
+class _Mode(str, Enum):
+    NONE = ""
+    PAN = "pan/zoom"
+    ZOOM = "zoom rect"
+
+class NavigationToolbar2:
+    toolitems: tuple[tuple[str, ...] | tuple[None, ...], ...]
+    UNKNOWN_SAVED_STATUS: object
+    canvas: FigureCanvasBase
+    mode: _Mode
+    def __init__(self, canvas: FigureCanvasBase) -> None: ...
+    def set_message(self, s: str) -> None: ...
+    def draw_rubberband(
+        self, event: Event, x0: float, y0: float, x1: float, y1: float
+    ) -> None: ...
+    def remove_rubberband(self) -> None: ...
+    def home(self, *args) -> None: ...
+    def back(self, *args) -> None: ...
+    def forward(self, *args) -> None: ...
+    def mouse_move(self, event: MouseEvent) -> None: ...
+    def pan(self, *args) -> None: ...
+
+    class _PanInfo(NamedTuple):
+        button: MouseButton
+        axes: list[Axes]
+        cid: int
+    def press_pan(self, event: Event) -> None: ...
+    def drag_pan(self, event: Event) -> None: ...
+    def release_pan(self, event: Event) -> None: ...
+    def zoom(self, *args) -> None: ...
+
+    class _ZoomInfo(NamedTuple):
+        direction: Literal["in", "out"]
+        start_xy: tuple[float, float]
+        axes: list[Axes]
+        cid: int
+        cbar: Colorbar
+    def press_zoom(self, event: Event) -> None: ...
+    def drag_zoom(self, event: Event) -> None: ...
+    def release_zoom(self, event: Event) -> None: ...
+    def push_current(self) -> None: ...
+    subplot_tool: widgets.SubplotTool
+    def configure_subplots(self, *args): ...
+    def save_figure(self, *args) -> str | None | object: ...
+    def update(self) -> None: ...
+    def set_history_buttons(self) -> None: ...
+
+class ToolContainerBase:
+    toolmanager: ToolManager
+    def __init__(self, toolmanager: ToolManager) -> None: ...
+    def add_tool(self, tool: ToolBase, group: str, position: int = ...) -> None: ...
+    def trigger_tool(self, name: str) -> None: ...
+    def add_toolitem(
+        self,
+        name: str,
+        group: str,
+        position: int,
+        image: str,
+        description: str,
+        toggle: bool,
+    ) -> None: ...
+    def toggle_toolitem(self, name: str, toggled: bool) -> None: ...
+    def remove_toolitem(self, name: str) -> None: ...
+    def set_message(self, s: str) -> None: ...
+
+class _Backend:
+    backend_version: str
+    FigureCanvas: type[FigureCanvasBase] | None
+    FigureManager: type[FigureManagerBase]
+    mainloop: None | Callable[[], Any]
+    @classmethod
+    def new_figure_manager(cls, num: int | str, *args, **kwargs) -> FigureManagerBase: ...
+    @classmethod
+    def new_figure_manager_given_figure(cls, num: int | str, figure: Figure) -> FigureManagerBase: ...
+    @classmethod
+    def draw_if_interactive(cls) -> None: ...
+    @classmethod
+    def show(cls, *, block: bool | None = ...) -> None: ...
+    @staticmethod
+    def export(cls) -> type[_Backend]: ...
+
+class ShowBase(_Backend):
+    def __call__(self, block: bool | None = ...) -> None: ...

infer_4_30_0/lib/python3.10/site-packages/matplotlib/backend_managers.py

@@ -0,0 +1,387 @@
+from matplotlib import _api, backend_tools, cbook, widgets
+
+
+class ToolEvent:
+    """Event for tool manipulation (add/remove)."""
+    def __init__(self, name, sender, tool, data=None):
+        self.name = name
+        self.sender = sender
+        self.tool = tool
+        self.data = data
+
+
+class ToolTriggerEvent(ToolEvent):
+    """Event to inform that a tool has been triggered."""
+    def __init__(self, name, sender, tool, canvasevent=None, data=None):
+        super().__init__(name, sender, tool, data)
+        self.canvasevent = canvasevent
+
+
+class ToolManagerMessageEvent:
+    """
+    Event carrying messages from toolmanager.
+
+    Messages usually get displayed to the user by the toolbar.
+    """
+    def __init__(self, name, sender, message):
+        self.name = name
+        self.sender = sender
+        self.message = message
+
+
+class ToolManager:
+    """
+    Manager for actions triggered by user interactions (key press, toolbar
+    clicks, ...) on a Figure.
+
+    Attributes
+    ----------
+    figure : `.Figure`
+    keypresslock : `~matplotlib.widgets.LockDraw`
+        `.LockDraw` object to know if the `canvas` key_press_event is locked.
+    messagelock : `~matplotlib.widgets.LockDraw`
+        `.LockDraw` object to know if the message is available to write.
+    """
+
+    def __init__(self, figure=None):
+
+        self._key_press_handler_id = None
+
+        self._tools = {}
+        self._keys = {}
+        self._toggled = {}
+        self._callbacks = cbook.CallbackRegistry()
+
+        # to process keypress event
+        self.keypresslock = widgets.LockDraw()
+        self.messagelock = widgets.LockDraw()
+
+        self._figure = None
+        self.set_figure(figure)
+
+    @property
+    def canvas(self):
+        """Canvas managed by FigureManager."""
+        if not self._figure:
+            return None
+        return self._figure.canvas
+
+    @property
+    def figure(self):
+        """Figure that holds the canvas."""
+        return self._figure
+
+    @figure.setter
+    def figure(self, figure):
+        self.set_figure(figure)
+
+    def set_figure(self, figure, update_tools=True):
+        """
+        Bind the given figure to the tools.
+
+        Parameters
+        ----------
+        figure : `.Figure`
+        update_tools : bool, default: True
+            Force tools to update figure.
+        """
+        if self._key_press_handler_id:
+            self.canvas.mpl_disconnect(self._key_press_handler_id)
+        self._figure = figure
+        if figure:
+            self._key_press_handler_id = self.canvas.mpl_connect(
+                'key_press_event', self._key_press)
+        if update_tools:
+            for tool in self._tools.values():
+                tool.figure = figure
+
+    def toolmanager_connect(self, s, func):
+        """
+        Connect event with string *s* to *func*.
+
+        Parameters
+        ----------
+        s : str
+            The name of the event. The following events are recognized:
+
+            - 'tool_message_event'
+            - 'tool_removed_event'
+            - 'tool_added_event'
+
+            For every tool added a new event is created
+
+            - 'tool_trigger_TOOLNAME', where TOOLNAME is the id of the tool.
+
+        func : callable
+            Callback function for the toolmanager event with signature::
+
+                def func(event: ToolEvent) -> Any
+
+        Returns
+        -------
+        cid
+            The callback id for the connection. This can be used in
+            `.toolmanager_disconnect`.
+        """
+        return self._callbacks.connect(s, func)
+
+    def toolmanager_disconnect(self, cid):
+        """
+        Disconnect callback id *cid*.
+
+        Example usage::
+
+            cid = toolmanager.toolmanager_connect('tool_trigger_zoom', onpress)
+            #...later
+            toolmanager.toolmanager_disconnect(cid)
+        """
+        return self._callbacks.disconnect(cid)
+
+    def message_event(self, message, sender=None):
+        """Emit a `ToolManagerMessageEvent`."""
+        if sender is None:
+            sender = self
+
+        s = 'tool_message_event'
+        event = ToolManagerMessageEvent(s, sender, message)
+        self._callbacks.process(s, event)
+
+    @property
+    def active_toggle(self):
+        """Currently toggled tools."""
+        return self._toggled
+
+    def get_tool_keymap(self, name):
+        """
+        Return the keymap associated with the specified tool.
+
+        Parameters
+        ----------
+        name : str
+            Name of the Tool.
+
+        Returns
+        -------
+        list of str
+            List of keys associated with the tool.
+        """
+
+        keys = [k for k, i in self._keys.items() if i == name]
+        return keys
+
+    def _remove_keys(self, name):
+        for k in self.get_tool_keymap(name):
+            del self._keys[k]
+
+    def update_keymap(self, name, key):
+        """
+        Set the keymap to associate with the specified tool.
+
+        Parameters
+        ----------
+        name : str
+            Name of the Tool.
+        key : str or list of str
+            Keys to associate with the tool.
+        """
+        if name not in self._tools:
+            raise KeyError(f'{name!r} not in Tools')
+        self._remove_keys(name)
+        if isinstance(key, str):
+            key = [key]
+        for k in key:
+            if k in self._keys:
+                _api.warn_external(
+                    f'Key {k} changed from {self._keys[k]} to {name}')
+            self._keys[k] = name
+
+    def remove_tool(self, name):
+        """
+        Remove tool named *name*.
+
+        Parameters
+        ----------
+        name : str
+            Name of the tool.
+        """
+        tool = self.get_tool(name)
+        if getattr(tool, 'toggled', False):  # If it's a toggled toggle tool, untoggle
+            self.trigger_tool(tool, 'toolmanager')
+        self._remove_keys(name)
+        event = ToolEvent('tool_removed_event', self, tool)
+        self._callbacks.process(event.name, event)
+        del self._tools[name]
+
+    def add_tool(self, name, tool, *args, **kwargs):
+        """
+        Add *tool* to `ToolManager`.
+
+        If successful, adds a new event ``tool_trigger_{name}`` where
+        ``{name}`` is the *name* of the tool; the event is fired every time the
+        tool is triggered.
+
+        Parameters
+        ----------
+        name : str
+            Name of the tool, treated as the ID, has to be unique.
+        tool : type
+            Class of the tool to be added.  A subclass will be used
+            instead if one was registered for the current canvas class.
+        *args, **kwargs
+            Passed to the *tool*'s constructor.
+
+        See Also
+        --------
+        matplotlib.backend_tools.ToolBase : The base class for tools.
+        """
+
+        tool_cls = backend_tools._find_tool_class(type(self.canvas), tool)
+        if not tool_cls:
+            raise ValueError('Impossible to find class for %s' % str(tool))
+
+        if name in self._tools:
+            _api.warn_external('A "Tool class" with the same name already '
+                               'exists, not added')
+            return self._tools[name]
+
+        tool_obj = tool_cls(self, name, *args, **kwargs)
+        self._tools[name] = tool_obj
+
+        if tool_obj.default_keymap is not None:
+            self.update_keymap(name, tool_obj.default_keymap)
+
+        # For toggle tools init the radio_group in self._toggled
+        if isinstance(tool_obj, backend_tools.ToolToggleBase):
+            # None group is not mutually exclusive, a set is used to keep track
+            # of all toggled tools in this group
+            if tool_obj.radio_group is None:
+                self._toggled.setdefault(None, set())
+            else:
+                self._toggled.setdefault(tool_obj.radio_group, None)
+
+            # If initially toggled
+            if tool_obj.toggled:
+                self._handle_toggle(tool_obj, None, None)
+        tool_obj.set_figure(self.figure)
+
+        event = ToolEvent('tool_added_event', self, tool_obj)
+        self._callbacks.process(event.name, event)
+
+        return tool_obj
+
+    def _handle_toggle(self, tool, canvasevent, data):
+        """
+        Toggle tools, need to untoggle prior to using other Toggle tool.
+        Called from trigger_tool.
+
+        Parameters
+        ----------
+        tool : `.ToolBase`
+        canvasevent : Event
+            Original Canvas event or None.
+        data : object
+            Extra data to pass to the tool when triggering.
+        """
+
+        radio_group = tool.radio_group
+        # radio_group None is not mutually exclusive
+        # just keep track of toggled tools in this group
+        if radio_group is None:
+            if tool.name in self._toggled[None]:
+                self._toggled[None].remove(tool.name)
+            else:
+                self._toggled[None].add(tool.name)
+            return
+
+        # If the tool already has a toggled state, untoggle it
+        if self._toggled[radio_group] == tool.name:
+            toggled = None
+        # If no tool was toggled in the radio_group
+        # toggle it
+        elif self._toggled[radio_group] is None:
+            toggled = tool.name
+        # Other tool in the radio_group is toggled
+        else:
+            # Untoggle previously toggled tool
+            self.trigger_tool(self._toggled[radio_group],
+                              self,
+                              canvasevent,
+                              data)
+            toggled = tool.name
+
+        # Keep track of the toggled tool in the radio_group
+        self._toggled[radio_group] = toggled
+
+    def trigger_tool(self, name, sender=None, canvasevent=None, data=None):
+        """
+        Trigger a tool and emit the ``tool_trigger_{name}`` event.
+
+        Parameters
+        ----------
+        name : str
+            Name of the tool.
+        sender : object
+            Object that wishes to trigger the tool.
+        canvasevent : Event
+            Original Canvas event or None.
+        data : object
+            Extra data to pass to the tool when triggering.
+        """
+        tool = self.get_tool(name)
+        if tool is None:
+            return
+
+        if sender is None:
+            sender = self
+
+        if isinstance(tool, backend_tools.ToolToggleBase):
+            self._handle_toggle(tool, canvasevent, data)
+
+        tool.trigger(sender, canvasevent, data)  # Actually trigger Tool.
+
+        s = 'tool_trigger_%s' % name
+        event = ToolTriggerEvent(s, sender, tool, canvasevent, data)
+        self._callbacks.process(s, event)
+
+    def _key_press(self, event):
+        if event.key is None or self.keypresslock.locked():
+            return
+
+        name = self._keys.get(event.key, None)
+        if name is None:
+            return
+        self.trigger_tool(name, canvasevent=event)
+
+    @property
+    def tools(self):
+        """A dict mapping tool name -> controlled tool."""
+        return self._tools
+
+    def get_tool(self, name, warn=True):
+        """
+        Return the tool object with the given name.
+
+        For convenience, this passes tool objects through.
+
+        Parameters
+        ----------
+        name : str or `.ToolBase`
+            Name of the tool, or the tool itself.
+        warn : bool, default: True
+            Whether a warning should be emitted it no tool with the given name
+            exists.
+
+        Returns
+        -------
+        `.ToolBase` or None
+            The tool or None if no tool with the given name exists.
+        """
+        if (isinstance(name, backend_tools.ToolBase)
+                and name.name in self._tools):
+            return name
+        if name not in self._tools:
+            if warn:
+                _api.warn_external(
+                    f"ToolManager does not control tool {name!r}")
+            return None
+        return self._tools[name]

infer_4_30_0/lib/python3.10/site-packages/matplotlib/backend_managers.pyi

@@ -0,0 +1,64 @@
+from matplotlib import backend_tools, widgets
+from matplotlib.backend_bases import FigureCanvasBase
+from matplotlib.figure import Figure
+
+from collections.abc import Callable, Iterable
+from typing import Any, TypeVar
+
+class ToolEvent:
+    name: str
+    sender: Any
+    tool: backend_tools.ToolBase
+    data: Any
+    def __init__(self, name, sender, tool, data: Any | None = ...) -> None: ...
+
+class ToolTriggerEvent(ToolEvent):
+    canvasevent: ToolEvent
+    def __init__(
+        self,
+        name,
+        sender,
+        tool,
+        canvasevent: ToolEvent | None = ...,
+        data: Any | None = ...,
+    ) -> None: ...
+
+class ToolManagerMessageEvent:
+    name: str
+    sender: Any
+    message: str
+    def __init__(self, name: str, sender: Any, message: str) -> None: ...
+
+class ToolManager:
+    keypresslock: widgets.LockDraw
+    messagelock: widgets.LockDraw
+    def __init__(self, figure: Figure | None = ...) -> None: ...
+    @property
+    def canvas(self) -> FigureCanvasBase | None: ...
+    @property
+    def figure(self) -> Figure | None: ...
+    @figure.setter
+    def figure(self, figure: Figure) -> None: ...
+    def set_figure(self, figure: Figure, update_tools: bool = ...) -> None: ...
+    def toolmanager_connect(self, s: str, func: Callable[[ToolEvent], Any]) -> int: ...
+    def toolmanager_disconnect(self, cid: int) -> None: ...
+    def message_event(self, message: str, sender: Any | None = ...) -> None: ...
+    @property
+    def active_toggle(self) -> dict[str | None, list[str] | str]: ...
+    def get_tool_keymap(self, name: str) -> list[str]: ...
+    def update_keymap(self, name: str, key: str | Iterable[str]) -> None: ...
+    def remove_tool(self, name: str) -> None: ...
+    _T = TypeVar("_T", bound=backend_tools.ToolBase)
+    def add_tool(self, name: str, tool: type[_T], *args, **kwargs) -> _T: ...
+    def trigger_tool(
+        self,
+        name: str | backend_tools.ToolBase,
+        sender: Any | None = ...,
+        canvasevent: ToolEvent | None = ...,
+        data: Any | None = ...,
+    ) -> None: ...
+    @property
+    def tools(self) -> dict[str, backend_tools.ToolBase]: ...
+    def get_tool(
+        self, name: str | backend_tools.ToolBase, warn: bool = ...
+    ) -> backend_tools.ToolBase | None: ...

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

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

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

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

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

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

infer_4_30_0/lib/python3.10/site-packages/matplotlib/colorbar.pyi

@@ -0,0 +1,139 @@
+import matplotlib.spines as mspines
+from matplotlib import cm, collections, colors, contour, colorizer
+from matplotlib.axes import Axes
+from matplotlib.axis import Axis
+from matplotlib.backend_bases import RendererBase
+from matplotlib.patches import Patch
+from matplotlib.ticker import Locator, Formatter
+from matplotlib.transforms import Bbox
+
+import numpy as np
+from numpy.typing import ArrayLike
+from collections.abc import Sequence
+from typing import Any, Literal, overload
+from .typing import ColorType
+
+class _ColorbarSpine(mspines.Spines):
+    def __init__(self, axes: Axes): ...
+    def get_window_extent(self, renderer: RendererBase | None = ...) -> Bbox:...
+    def set_xy(self, xy: ArrayLike) -> None: ...
+    def draw(self, renderer: RendererBase | None) -> None:...
+
+
+class Colorbar:
+    n_rasterize: int
+    mappable: cm.ScalarMappable | colorizer.ColorizingArtist
+    ax: Axes
+    alpha: float | None
+    cmap: colors.Colormap
+    norm: colors.Normalize
+    values: Sequence[float] | None
+    boundaries: Sequence[float] | None
+    extend: Literal["neither", "both", "min", "max"]
+    spacing: Literal["uniform", "proportional"]
+    orientation: Literal["vertical", "horizontal"]
+    drawedges: bool
+    extendfrac: Literal["auto"] | float | Sequence[float] | None
+    extendrect: bool
+    solids: None | collections.QuadMesh
+    solids_patches: list[Patch]
+    lines: list[collections.LineCollection]
+    outline: _ColorbarSpine
+    dividers: collections.LineCollection
+    ticklocation: Literal["left", "right", "top", "bottom"]
+    def __init__(
+        self,
+        ax: Axes,
+        mappable: cm.ScalarMappable | colorizer.ColorizingArtist | None = ...,
+        *,
+        cmap: str | colors.Colormap | None = ...,
+        norm: colors.Normalize | None = ...,
+        alpha: float | None = ...,
+        values: Sequence[float] | None = ...,
+        boundaries: Sequence[float] | None = ...,
+        orientation: Literal["vertical", "horizontal"] | None = ...,
+        ticklocation: Literal["auto", "left", "right", "top", "bottom"] = ...,
+        extend: Literal["neither", "both", "min", "max"] | None = ...,
+        spacing: Literal["uniform", "proportional"] = ...,
+        ticks: Sequence[float] | Locator | None = ...,
+        format: str | Formatter | None = ...,
+        drawedges: bool = ...,
+        extendfrac: Literal["auto"] | float | Sequence[float] | None = ...,
+        extendrect: bool = ...,
+        label: str = ...,
+        location: Literal["left", "right", "top", "bottom"] | None = ...
+    ) -> None: ...
+    @property
+    def long_axis(self) -> Axis: ...
+    @property
+    def locator(self) -> Locator: ...
+    @locator.setter
+    def locator(self, loc: Locator) -> None: ...
+    @property
+    def minorlocator(self) -> Locator: ...
+    @minorlocator.setter
+    def minorlocator(self, loc: Locator) -> None: ...
+    @property
+    def formatter(self) -> Formatter: ...
+    @formatter.setter
+    def formatter(self, fmt: Formatter) -> None: ...
+    @property
+    def minorformatter(self) -> Formatter: ...
+    @minorformatter.setter
+    def minorformatter(self, fmt: Formatter) -> None: ...
+    def update_normal(self, mappable: cm.ScalarMappable | None = ...) -> None: ...
+    @overload
+    def add_lines(self, CS: contour.ContourSet, erase: bool = ...) -> None: ...
+    @overload
+    def add_lines(
+        self,
+        levels: ArrayLike,
+        colors: ColorType | Sequence[ColorType],
+        linewidths: float | ArrayLike,
+        erase: bool = ...,
+    ) -> None: ...
+    def update_ticks(self) -> None: ...
+    def set_ticks(
+        self,
+        ticks: Sequence[float] | Locator,
+        *,
+        labels: Sequence[str] | None = ...,
+        minor: bool = ...,
+        **kwargs
+    ) -> None: ...
+    def get_ticks(self, minor: bool = ...) -> np.ndarray: ...
+    def set_ticklabels(
+        self,
+        ticklabels: Sequence[str],
+        *,
+        minor: bool = ...,
+        **kwargs
+    ) -> None: ...
+    def minorticks_on(self) -> None: ...
+    def minorticks_off(self) -> None: ...
+    def set_label(self, label: str, *, loc: str | None = ..., **kwargs) -> None: ...
+    def set_alpha(self, alpha: float | np.ndarray) -> None: ...
+    def remove(self) -> None: ...
+    def drag_pan(self, button: Any, key: Any, x: float, y: float) -> None: ...
+
+ColorbarBase = Colorbar
+
+def make_axes(
+    parents: Axes | list[Axes] | np.ndarray,
+    location: Literal["left", "right", "top", "bottom"] | None = ...,
+    orientation: Literal["vertical", "horizontal"] | None = ...,
+    fraction: float = ...,
+    shrink: float = ...,
+    aspect: float = ...,
+    **kwargs
+) -> tuple[Axes, dict[str, Any]]: ...
+def make_axes_gridspec(
+    parent: Axes,
+    *,
+    location: Literal["left", "right", "top", "bottom"] | None = ...,
+    orientation: Literal["vertical", "horizontal"] | None = ...,
+    fraction: float = ...,
+    shrink: float = ...,
+    aspect: float = ...,
+    **kwargs
+) -> tuple[Axes, dict[str, Any]]: ...

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

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

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

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

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

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

infer_4_30_0/lib/python3.10/site-packages/matplotlib/ft2font.pyi

@@ -0,0 +1,312 @@
+from enum import Enum, Flag
+import sys
+from typing import BinaryIO, Literal, TypedDict, final, overload, cast
+from typing_extensions import Buffer  # < Py 3.12
+
+import numpy as np
+from numpy.typing import NDArray
+
+__freetype_build_type__: str
+__freetype_version__: str
+
+class FaceFlags(Flag):
+    SCALABLE = cast(int, ...)
+    FIXED_SIZES = cast(int, ...)
+    FIXED_WIDTH = cast(int, ...)
+    SFNT = cast(int, ...)
+    HORIZONTAL = cast(int, ...)
+    VERTICAL = cast(int, ...)
+    KERNING = cast(int, ...)
+    FAST_GLYPHS = cast(int, ...)
+    MULTIPLE_MASTERS = cast(int, ...)
+    GLYPH_NAMES = cast(int, ...)
+    EXTERNAL_STREAM = cast(int, ...)
+    HINTER = cast(int, ...)
+    CID_KEYED = cast(int, ...)
+    TRICKY = cast(int, ...)
+    COLOR = cast(int, ...)
+    # VARIATION = cast(int, ...)  # FT 2.9
+    # SVG = cast(int, ...)  # FT 2.12
+    # SBIX = cast(int, ...)  # FT 2.12
+    # SBIX_OVERLAY = cast(int, ...)  # FT 2.12
+
+class Kerning(Enum):
+    DEFAULT = cast(int, ...)
+    UNFITTED = cast(int, ...)
+    UNSCALED = cast(int, ...)
+
+class LoadFlags(Flag):
+    DEFAULT = cast(int, ...)
+    NO_SCALE = cast(int, ...)
+    NO_HINTING = cast(int, ...)
+    RENDER = cast(int, ...)
+    NO_BITMAP = cast(int, ...)
+    VERTICAL_LAYOUT = cast(int, ...)
+    FORCE_AUTOHINT = cast(int, ...)
+    CROP_BITMAP = cast(int, ...)
+    PEDANTIC = cast(int, ...)
+    IGNORE_GLOBAL_ADVANCE_WIDTH = cast(int, ...)
+    NO_RECURSE = cast(int, ...)
+    IGNORE_TRANSFORM = cast(int, ...)
+    MONOCHROME = cast(int, ...)
+    LINEAR_DESIGN = cast(int, ...)
+    NO_AUTOHINT = cast(int, ...)
+    COLOR = cast(int, ...)
+    COMPUTE_METRICS = cast(int, ...)  # FT 2.6.1
+    # BITMAP_METRICS_ONLY = cast(int, ...)  # FT 2.7.1
+    # NO_SVG = cast(int, ...)  # FT 2.13.1
+    # The following should be unique, but the above can be OR'd together.
+    TARGET_NORMAL = cast(int, ...)
+    TARGET_LIGHT = cast(int, ...)
+    TARGET_MONO = cast(int, ...)
+    TARGET_LCD = cast(int, ...)
+    TARGET_LCD_V = cast(int, ...)
+
+class StyleFlags(Flag):
+    NORMAL = cast(int, ...)
+    ITALIC = cast(int, ...)
+    BOLD = cast(int, ...)
+
+class _SfntHeadDict(TypedDict):
+    version: tuple[int, int]
+    fontRevision: tuple[int, int]
+    checkSumAdjustment: int
+    magicNumber: int
+    flags: int
+    unitsPerEm: int
+    created: tuple[int, int]
+    modified: tuple[int, int]
+    xMin: int
+    yMin: int
+    xMax: int
+    yMax: int
+    macStyle: int
+    lowestRecPPEM: int
+    fontDirectionHint: int
+    indexToLocFormat: int
+    glyphDataFormat: int
+
+class _SfntMaxpDict(TypedDict):
+    version: tuple[int, int]
+    numGlyphs: int
+    maxPoints: int
+    maxContours: int
+    maxComponentPoints: int
+    maxComponentContours: int
+    maxZones: int
+    maxTwilightPoints: int
+    maxStorage: int
+    maxFunctionDefs: int
+    maxInstructionDefs: int
+    maxStackElements: int
+    maxSizeOfInstructions: int
+    maxComponentElements: int
+    maxComponentDepth: int
+
+class _SfntOs2Dict(TypedDict):
+    version: int
+    xAvgCharWidth: int
+    usWeightClass: int
+    usWidthClass: int
+    fsType: int
+    ySubscriptXSize: int
+    ySubscriptYSize: int
+    ySubscriptXOffset: int
+    ySubscriptYOffset: int
+    ySuperscriptXSize: int
+    ySuperscriptYSize: int
+    ySuperscriptXOffset: int
+    ySuperscriptYOffset: int
+    yStrikeoutSize: int
+    yStrikeoutPosition: int
+    sFamilyClass: int
+    panose: bytes
+    ulCharRange: tuple[int, int, int, int]
+    achVendID: bytes
+    fsSelection: int
+    fsFirstCharIndex: int
+    fsLastCharIndex: int
+
+class _SfntHheaDict(TypedDict):
+    version: tuple[int, int]
+    ascent: int
+    descent: int
+    lineGap: int
+    advanceWidthMax: int
+    minLeftBearing: int
+    minRightBearing: int
+    xMaxExtent: int
+    caretSlopeRise: int
+    caretSlopeRun: int
+    caretOffset: int
+    metricDataFormat: int
+    numOfLongHorMetrics: int
+
+class _SfntVheaDict(TypedDict):
+    version: tuple[int, int]
+    vertTypoAscender: int
+    vertTypoDescender: int
+    vertTypoLineGap: int
+    advanceHeightMax: int
+    minTopSideBearing: int
+    minBottomSizeBearing: int
+    yMaxExtent: int
+    caretSlopeRise: int
+    caretSlopeRun: int
+    caretOffset: int
+    metricDataFormat: int
+    numOfLongVerMetrics: int
+
+class _SfntPostDict(TypedDict):
+    format: tuple[int, int]
+    italicAngle: tuple[int, int]
+    underlinePosition: int
+    underlineThickness: int
+    isFixedPitch: int
+    minMemType42: int
+    maxMemType42: int
+    minMemType1: int
+    maxMemType1: int
+
+class _SfntPcltDict(TypedDict):
+    version: tuple[int, int]
+    fontNumber: int
+    pitch: int
+    xHeight: int
+    style: int
+    typeFamily: int
+    capHeight: int
+    symbolSet: int
+    typeFace: bytes
+    characterComplement: bytes
+    strokeWeight: int
+    widthType: int
+    serifStyle: int
+
+@final
+class FT2Font(Buffer):
+    def __init__(
+        self,
+        filename: str | BinaryIO,
+        hinting_factor: int = ...,
+        *,
+        _fallback_list: list[FT2Font] | None = ...,
+        _kerning_factor: int = ...
+    ) -> None: ...
+    if sys.version_info[:2] >= (3, 12):
+        def __buffer__(self, flags: int) -> memoryview: ...
+    def _get_fontmap(self, string: str) -> dict[str, FT2Font]: ...
+    def clear(self) -> None: ...
+    def draw_glyph_to_bitmap(
+        self, image: FT2Image, x: int, y: int, glyph: Glyph, antialiased: bool = ...
+    ) -> None: ...
+    def draw_glyphs_to_bitmap(self, antialiased: bool = ...) -> None: ...
+    def get_bitmap_offset(self) -> tuple[int, int]: ...
+    def get_char_index(self, codepoint: int) -> int: ...
+    def get_charmap(self) -> dict[int, int]: ...
+    def get_descent(self) -> int: ...
+    def get_glyph_name(self, index: int) -> str: ...
+    def get_image(self) -> NDArray[np.uint8]: ...
+    def get_kerning(self, left: int, right: int, mode: Kerning) -> int: ...
+    def get_name_index(self, name: str) -> int: ...
+    def get_num_glyphs(self) -> int: ...
+    def get_path(self) -> tuple[NDArray[np.float64], NDArray[np.int8]]: ...
+    def get_ps_font_info(
+        self,
+    ) -> tuple[str, str, str, str, str, int, int, int, int]: ...
+    def get_sfnt(self) -> dict[tuple[int, int, int, int], bytes]: ...
+    @overload
+    def get_sfnt_table(self, name: Literal["head"]) -> _SfntHeadDict | None: ...
+    @overload
+    def get_sfnt_table(self, name: Literal["maxp"]) -> _SfntMaxpDict | None: ...
+    @overload
+    def get_sfnt_table(self, name: Literal["OS/2"]) -> _SfntOs2Dict | None: ...
+    @overload
+    def get_sfnt_table(self, name: Literal["hhea"]) -> _SfntHheaDict | None: ...
+    @overload
+    def get_sfnt_table(self, name: Literal["vhea"]) -> _SfntVheaDict | None: ...
+    @overload
+    def get_sfnt_table(self, name: Literal["post"]) -> _SfntPostDict | None: ...
+    @overload
+    def get_sfnt_table(self, name: Literal["pclt"]) -> _SfntPcltDict | None: ...
+    def get_width_height(self) -> tuple[int, int]: ...
+    def load_char(self, charcode: int, flags: LoadFlags = ...) -> Glyph: ...
+    def load_glyph(self, glyphindex: int, flags: LoadFlags = ...) -> Glyph: ...
+    def select_charmap(self, i: int) -> None: ...
+    def set_charmap(self, i: int) -> None: ...
+    def set_size(self, ptsize: float, dpi: float) -> None: ...
+    def set_text(
+        self, string: str, angle: float = ..., flags: LoadFlags = ...
+    ) -> NDArray[np.float64]: ...
+    @property
+    def ascender(self) -> int: ...
+    @property
+    def bbox(self) -> tuple[int, int, int, int]: ...
+    @property
+    def descender(self) -> int: ...
+    @property
+    def face_flags(self) -> FaceFlags: ...
+    @property
+    def family_name(self) -> str: ...
+    @property
+    def fname(self) -> str: ...
+    @property
+    def height(self) -> int: ...
+    @property
+    def max_advance_height(self) -> int: ...
+    @property
+    def max_advance_width(self) -> int: ...
+    @property
+    def num_charmaps(self) -> int: ...
+    @property
+    def num_faces(self) -> int: ...
+    @property
+    def num_fixed_sizes(self) -> int: ...
+    @property
+    def num_glyphs(self) -> int: ...
+    @property
+    def num_named_instances(self) -> int: ...
+    @property
+    def postscript_name(self) -> str: ...
+    @property
+    def scalable(self) -> bool: ...
+    @property
+    def style_flags(self) -> StyleFlags: ...
+    @property
+    def style_name(self) -> str: ...
+    @property
+    def underline_position(self) -> int: ...
+    @property
+    def underline_thickness(self) -> int: ...
+    @property
+    def units_per_EM(self) -> int: ...
+
+@final
+class FT2Image(Buffer):
+    def __init__(self, width: int, height: int) -> None: ...
+    def draw_rect_filled(self, x0: int, y0: int, x1: int, y1: int) -> None: ...
+    if sys.version_info[:2] >= (3, 12):
+        def __buffer__(self, flags: int) -> memoryview: ...
+
+@final
+class Glyph:
+    @property
+    def width(self) -> int: ...
+    @property
+    def height(self) -> int: ...
+    @property
+    def horiBearingX(self) -> int: ...
+    @property
+    def horiBearingY(self) -> int: ...
+    @property
+    def horiAdvance(self) -> int: ...
+    @property
+    def linearHoriAdvance(self) -> int: ...
+    @property
+    def vertBearingX(self) -> int: ...
+    @property
+    def vertBearingY(self) -> int: ...
+    @property
+    def vertAdvance(self) -> int: ...
+    @property
+    def bbox(self) -> tuple[int, int, int, int]: ...

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

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

infer_4_30_0/lib/python3.10/site-packages/matplotlib/gridspec.pyi

@@ -0,0 +1,160 @@
+from typing import Any, Literal, overload
+
+from numpy.typing import ArrayLike
+import numpy as np
+
+from matplotlib.axes import Axes
+from matplotlib.backend_bases import RendererBase
+from matplotlib.figure import Figure
+from matplotlib.transforms import Bbox
+
+class GridSpecBase:
+    def __init__(
+        self,
+        nrows: int,
+        ncols: int,
+        height_ratios: ArrayLike | None = ...,
+        width_ratios: ArrayLike | None = ...,
+    ) -> None: ...
+    @property
+    def nrows(self) -> int: ...
+    @property
+    def ncols(self) -> int: ...
+    def get_geometry(self) -> tuple[int, int]: ...
+    def get_subplot_params(self, figure: Figure | None = ...) -> SubplotParams: ...
+    def new_subplotspec(
+        self, loc: tuple[int, int], rowspan: int = ..., colspan: int = ...
+    ) -> SubplotSpec: ...
+    def set_width_ratios(self, width_ratios: ArrayLike | None) -> None: ...
+    def get_width_ratios(self) -> ArrayLike: ...
+    def set_height_ratios(self, height_ratios: ArrayLike | None) -> None: ...
+    def get_height_ratios(self) -> ArrayLike: ...
+    def get_grid_positions(
+        self, fig: Figure
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: ...
+    @staticmethod
+    def _check_gridspec_exists(figure: Figure, nrows: int, ncols: int) -> GridSpec: ...
+    def __getitem__(
+        self, key: tuple[int | slice, int | slice] | slice | int
+    ) -> SubplotSpec: ...
+    @overload
+    def subplots(
+        self,
+        *,
+        sharex: bool | Literal["all", "row", "col", "none"] = ...,
+        sharey: bool | Literal["all", "row", "col", "none"] = ...,
+        squeeze: Literal[False],
+        subplot_kw: dict[str, Any] | None = ...
+    ) -> np.ndarray: ...
+    @overload
+    def subplots(
+        self,
+        *,
+        sharex: bool | Literal["all", "row", "col", "none"] = ...,
+        sharey: bool | Literal["all", "row", "col", "none"] = ...,
+        squeeze: Literal[True] = ...,
+        subplot_kw: dict[str, Any] | None = ...
+    ) -> np.ndarray | Axes: ...
+
+class GridSpec(GridSpecBase):
+    left: float | None
+    bottom: float | None
+    right: float | None
+    top: float | None
+    wspace: float | None
+    hspace: float | None
+    figure: Figure | None
+    def __init__(
+        self,
+        nrows: int,
+        ncols: int,
+        figure: Figure | None = ...,
+        left: float | None = ...,
+        bottom: float | None = ...,
+        right: float | None = ...,
+        top: float | None = ...,
+        wspace: float | None = ...,
+        hspace: float | None = ...,
+        width_ratios: ArrayLike | None = ...,
+        height_ratios: ArrayLike | None = ...,
+    ) -> None: ...
+    def update(self, **kwargs: float | None) -> None: ...
+    def locally_modified_subplot_params(self) -> list[str]: ...
+    def tight_layout(
+        self,
+        figure: Figure,
+        renderer: RendererBase | None = ...,
+        pad: float = ...,
+        h_pad: float | None = ...,
+        w_pad: float | None = ...,
+        rect: tuple[float, float, float, float] | None = ...,
+    ) -> None: ...
+
+class GridSpecFromSubplotSpec(GridSpecBase):
+    figure: Figure | None
+    def __init__(
+        self,
+        nrows: int,
+        ncols: int,
+        subplot_spec: SubplotSpec,
+        wspace: float | None = ...,
+        hspace: float | None = ...,
+        height_ratios: ArrayLike | None = ...,
+        width_ratios: ArrayLike | None = ...,
+    ) -> None: ...
+    def get_topmost_subplotspec(self) -> SubplotSpec: ...
+
+class SubplotSpec:
+    num1: int
+    def __init__(
+        self, gridspec: GridSpecBase, num1: int, num2: int | None = ...
+    ) -> None: ...
+    @staticmethod
+    def _from_subplot_args(figure, args): ...
+    @property
+    def num2(self) -> int: ...
+    @num2.setter
+    def num2(self, value: int) -> None: ...
+    def get_gridspec(self) -> GridSpec: ...
+    def get_geometry(self) -> tuple[int, int, int, int]: ...
+    @property
+    def rowspan(self) -> range: ...
+    @property
+    def colspan(self) -> range: ...
+    def is_first_row(self) -> bool: ...
+    def is_last_row(self) -> bool: ...
+    def is_first_col(self) -> bool: ...
+    def is_last_col(self) -> bool: ...
+    def get_position(self, figure: Figure) -> Bbox: ...
+    def get_topmost_subplotspec(self) -> SubplotSpec: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def subgridspec(
+        self, nrows: int, ncols: int, **kwargs
+    ) -> GridSpecFromSubplotSpec: ...
+
+class SubplotParams:
+    def __init__(
+        self,
+        left: float | None = ...,
+        bottom: float | None = ...,
+        right: float | None = ...,
+        top: float | None = ...,
+        wspace: float | None = ...,
+        hspace: float | None = ...,
+    ) -> None: ...
+    left: float
+    right: float
+    bottom: float
+    top: float
+    wspace: float
+    hspace: float
+    def update(
+        self,
+        left: float | None = ...,
+        bottom: float | None = ...,
+        right: float | None = ...,
+        top: float | None = ...,
+        wspace: float | None = ...,
+        hspace: float | None = ...,
+    ) -> None: ...

infer_4_30_0/lib/python3.10/site-packages/matplotlib/inset.py

@@ -0,0 +1,269 @@
+"""
+The inset module defines the InsetIndicator class, which draws the rectangle and
+connectors required for `.Axes.indicate_inset` and `.Axes.indicate_inset_zoom`.
+"""
+
+from . import _api, artist, transforms
+from matplotlib.patches import ConnectionPatch, PathPatch, Rectangle
+from matplotlib.path import Path
+
+
+_shared_properties = ('alpha', 'edgecolor', 'linestyle', 'linewidth')
+
+
+class InsetIndicator(artist.Artist):
+    """
+    An artist to highlight an area of interest.
+
+    An inset indicator is a rectangle on the plot at the position indicated by
+    *bounds* that optionally has lines that connect the rectangle to an inset
+    Axes (`.Axes.inset_axes`).
+
+    .. versionadded:: 3.10
+    """
+    zorder = 4.99
+
+    def __init__(self, bounds=None, inset_ax=None, zorder=None, **kwargs):
+        """
+        Parameters
+        ----------
+        bounds : [x0, y0, width, height], optional
+            Lower-left corner of rectangle to be marked, and its width
+            and height.  If not set, the bounds will be calculated from the
+            data limits of inset_ax, which must be supplied.
+
+        inset_ax : `~.axes.Axes`, optional
+            An optional inset Axes to draw connecting lines to.  Two lines are
+            drawn connecting the indicator box to the inset Axes on corners
+            chosen so as to not overlap with the indicator box.
+
+        zorder : float, default: 4.99
+            Drawing order of the rectangle and connector lines.  The default,
+            4.99, is just below the default level of inset Axes.
+
+        **kwargs
+            Other keyword arguments are passed on to the `.Rectangle` patch.
+        """
+        if bounds is None and inset_ax is None:
+            raise ValueError("At least one of bounds or inset_ax must be supplied")
+
+        self._inset_ax = inset_ax
+
+        if bounds is None:
+            # Work out bounds from inset_ax
+            self._auto_update_bounds = True
+            bounds = self._bounds_from_inset_ax()
+        else:
+            self._auto_update_bounds = False
+
+        x, y, width, height = bounds
+
+        self._rectangle = Rectangle((x, y), width, height, clip_on=False, **kwargs)
+
+        # Connector positions cannot be calculated till the artist has been added
+        # to an axes, so just make an empty list for now.
+        self._connectors = []
+
+        super().__init__()
+        self.set_zorder(zorder)
+
+        # Initial style properties for the artist should match the rectangle.
+        for prop in _shared_properties:
+            setattr(self, f'_{prop}', artist.getp(self._rectangle, prop))
+
+    def _shared_setter(self, prop, val):
+        """
+        Helper function to set the same style property on the artist and its children.
+        """
+        setattr(self, f'_{prop}', val)
+
+        artist.setp([self._rectangle, *self._connectors], prop, val)
+
+    def set_alpha(self, alpha):
+        # docstring inherited
+        self._shared_setter('alpha', alpha)
+
+    def set_edgecolor(self, color):
+        """
+        Set the edge color of the rectangle and the connectors.
+
+        Parameters
+        ----------
+        color : :mpltype:`color` or None
+        """
+        self._shared_setter('edgecolor', color)
+
+    def set_color(self, c):
+        """
+        Set the edgecolor of the rectangle and the connectors, and the
+        facecolor for the rectangle.
+
+        Parameters
+        ----------
+        c : :mpltype:`color`
+        """
+        self._shared_setter('edgecolor', c)
+        self._shared_setter('facecolor', c)
+
+    def set_linewidth(self, w):
+        """
+        Set the linewidth in points of the rectangle and the connectors.
+
+        Parameters
+        ----------
+        w : float or None
+        """
+        self._shared_setter('linewidth', w)
+
+    def set_linestyle(self, ls):
+        """
+        Set the linestyle of the rectangle and the connectors.
+
+        ==========================================  =================
+        linestyle                                   description
+        ==========================================  =================
+        ``'-'`` or ``'solid'``                      solid line
+        ``'--'`` or ``'dashed'``                    dashed line
+        ``'-.'`` or ``'dashdot'``                   dash-dotted line
+        ``':'`` or ``'dotted'``                     dotted line
+        ``'none'``, ``'None'``, ``' '``, or ``''``  draw nothing
+        ==========================================  =================
+
+        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 : {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
+            The line style.
+        """
+        self._shared_setter('linestyle', ls)
+
+    def _bounds_from_inset_ax(self):
+        xlim = self._inset_ax.get_xlim()
+        ylim = self._inset_ax.get_ylim()
+        return (xlim[0], ylim[0], xlim[1] - xlim[0], ylim[1] - ylim[0])
+
+    def _update_connectors(self):
+        (x, y) = self._rectangle.get_xy()
+        width = self._rectangle.get_width()
+        height = self._rectangle.get_height()
+
+        existing_connectors = self._connectors or [None] * 4
+
+        # connect the inset_axes to the rectangle
+        for xy_inset_ax, existing in zip([(0, 0), (0, 1), (1, 0), (1, 1)],
+                                         existing_connectors):
+            # inset_ax positions are in axes coordinates
+            # The 0, 1 values define the four edges if the inset_ax
+            # lower_left, upper_left, lower_right upper_right.
+            ex, ey = xy_inset_ax
+            if self.axes.xaxis.get_inverted():
+                ex = 1 - ex
+            if self.axes.yaxis.get_inverted():
+                ey = 1 - ey
+            xy_data = x + ex * width, y + ey * height
+            if existing is None:
+                # Create new connection patch with styles inherited from the
+                # parent artist.
+                p = ConnectionPatch(
+                    xyA=xy_inset_ax, coordsA=self._inset_ax.transAxes,
+                    xyB=xy_data, coordsB=self.axes.transData,
+                    arrowstyle="-",
+                    edgecolor=self._edgecolor, alpha=self.get_alpha(),
+                    linestyle=self._linestyle, linewidth=self._linewidth)
+                self._connectors.append(p)
+            else:
+                # Only update positioning of existing connection patch.  We
+                # do not want to override any style settings made by the user.
+                existing.xy1 = xy_inset_ax
+                existing.xy2 = xy_data
+                existing.coords1 = self._inset_ax.transAxes
+                existing.coords2 = self.axes.transData
+
+        if existing is None:
+            # decide which two of the lines to keep visible....
+            pos = self._inset_ax.get_position()
+            bboxins = pos.transformed(self.get_figure(root=False).transSubfigure)
+            rectbbox = transforms.Bbox.from_bounds(x, y, width, height).transformed(
+                self._rectangle.get_transform())
+            x0 = rectbbox.x0 < bboxins.x0
+            x1 = rectbbox.x1 < bboxins.x1
+            y0 = rectbbox.y0 < bboxins.y0
+            y1 = rectbbox.y1 < bboxins.y1
+            self._connectors[0].set_visible(x0 ^ y0)
+            self._connectors[1].set_visible(x0 == y1)
+            self._connectors[2].set_visible(x1 == y0)
+            self._connectors[3].set_visible(x1 ^ y1)
+
+    @property
+    def rectangle(self):
+        """`.Rectangle`: the indicator frame."""
+        return self._rectangle
+
+    @property
+    def connectors(self):
+        """
+        4-tuple of `.patches.ConnectionPatch` or None
+            The four connector lines connecting to (lower_left, upper_left,
+            lower_right upper_right) corners of *inset_ax*. Two lines are
+            set with visibility to *False*,  but the user can set the
+            visibility to True if the automatic choice is not deemed correct.
+        """
+        if self._inset_ax is None:
+            return
+
+        if self._auto_update_bounds:
+            self._rectangle.set_bounds(self._bounds_from_inset_ax())
+        self._update_connectors()
+        return tuple(self._connectors)
+
+    def draw(self, renderer):
+        # docstring inherited
+        conn_same_style = []
+
+        # Figure out which connectors have the same style as the box, so should
+        # be drawn as a single path.
+        for conn in self.connectors or []:
+            if conn.get_visible():
+                drawn = False
+                for s in _shared_properties:
+                    if artist.getp(self._rectangle, s) != artist.getp(conn, s):
+                        # Draw this connector by itself
+                        conn.draw(renderer)
+                        drawn = True
+                        break
+
+                if not drawn:
+                    # Connector has same style as box.
+                    conn_same_style.append(conn)
+
+        if conn_same_style:
+            # Since at least one connector has the same style as the rectangle, draw
+            # them as a compound path.
+            artists = [self._rectangle] + conn_same_style
+            paths = [a.get_transform().transform_path(a.get_path()) for a in artists]
+            path = Path.make_compound_path(*paths)
+
+            # Create a temporary patch to draw the path.
+            p = PathPatch(path)
+            p.update_from(self._rectangle)
+            p.set_transform(transforms.IdentityTransform())
+            p.draw(renderer)
+
+            return
+
+        # Just draw the rectangle
+        self._rectangle.draw(renderer)
+
+    @_api.deprecated(
+        '3.10',
+        message=('Since Matplotlib 3.10 indicate_inset_[zoom] returns a single '
+                 'InsetIndicator artist with a rectangle property and a connectors '
+                 'property.  From 3.12 it will no longer be possible to unpack the '
+                 'return value into two elements.'))
+    def __getitem__(self, key):
+        return [self._rectangle, self.connectors][key]

infer_4_30_0/lib/python3.10/site-packages/matplotlib/layout_engine.pyi

@@ -0,0 +1,62 @@
+from matplotlib.figure import Figure
+
+from typing import Any
+
+class LayoutEngine:
+    def __init__(self, **kwargs: Any) -> None: ...
+    def set(self) -> None: ...
+    @property
+    def colorbar_gridspec(self) -> bool: ...
+    @property
+    def adjust_compatible(self) -> bool: ...
+    def get(self) -> dict[str, Any]: ...
+    def execute(self, fig: Figure) -> None: ...
+
+class PlaceHolderLayoutEngine(LayoutEngine):
+    def __init__(
+        self, adjust_compatible: bool, colorbar_gridspec: bool, **kwargs: Any
+    ) -> None: ...
+    def execute(self, fig: Figure) -> None: ...
+
+class TightLayoutEngine(LayoutEngine):
+    def __init__(
+        self,
+        *,
+        pad: float = ...,
+        h_pad: float | None = ...,
+        w_pad: float | None = ...,
+        rect: tuple[float, float, float, float] = ...,
+        **kwargs: Any
+    ) -> None: ...
+    def execute(self, fig: Figure) -> None: ...
+    def set(
+        self,
+        *,
+        pad: float | None = ...,
+        w_pad: float | None = ...,
+        h_pad: float | None = ...,
+        rect: tuple[float, float, float, float] | None = ...
+    ) -> None: ...
+
+class ConstrainedLayoutEngine(LayoutEngine):
+    def __init__(
+        self,
+        *,
+        h_pad: float | None = ...,
+        w_pad: float | None = ...,
+        hspace: float | None = ...,
+        wspace: float | None = ...,
+        rect: tuple[float, float, float, float] = ...,
+        compress: bool = ...,
+        **kwargs: Any
+    ) -> None: ...
+    def execute(self, fig: Figure) -> Any: ...
+    def set(
+        self,
+        *,
+        h_pad: float | None = ...,
+        w_pad: float | None = ...,
+        hspace: float | None = ...,
+        wspace: float | None = ...,
+        rect: tuple[float, float, float, float] | None = ...
+    ) -> None: ...

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

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

infer_4_30_0/lib/python3.10/site-packages/matplotlib/legend_handler.pyi

@@ -0,0 +1,294 @@
+from collections.abc import Callable, Sequence
+from matplotlib.artist import Artist
+from matplotlib.legend import Legend
+from matplotlib.offsetbox import OffsetBox
+from matplotlib.transforms import Transform
+
+from typing import TypeVar
+
+from numpy.typing import ArrayLike
+
+def update_from_first_child(tgt: Artist, src: Artist) -> None: ...
+
+class HandlerBase:
+    def __init__(
+        self,
+        xpad: float = ...,
+        ypad: float = ...,
+        update_func: Callable[[Artist, Artist], None] | None = ...,
+    ) -> None: ...
+    def update_prop(
+        self, legend_handle: Artist, orig_handle: Artist, legend: Legend
+    ) -> None: ...
+    def adjust_drawing_area(
+        self,
+        legend: Legend,
+        orig_handle: Artist,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+    ) -> tuple[float, float, float, float]: ...
+    def legend_artist(
+        self, legend: Legend, orig_handle: Artist, fontsize: float, handlebox: OffsetBox
+    ) -> Artist: ...
+    def create_artists(
+        self,
+        legend: Legend,
+        orig_handle: Artist,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+        trans: Transform,
+    ) -> Sequence[Artist]: ...
+
+class HandlerNpoints(HandlerBase):
+    def __init__(
+        self, marker_pad: float = ..., numpoints: int | None = ..., **kwargs
+    ) -> None: ...
+    def get_numpoints(self, legend: Legend) -> int | None: ...
+    def get_xdata(
+        self,
+        legend: Legend,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+    ) -> tuple[ArrayLike, ArrayLike]: ...
+
+class HandlerNpointsYoffsets(HandlerNpoints):
+    def __init__(
+        self,
+        numpoints: int | None = ...,
+        yoffsets: Sequence[float] | None = ...,
+        **kwargs
+    ) -> None: ...
+    def get_ydata(
+        self,
+        legend: Legend,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+    ) -> ArrayLike: ...
+
+class HandlerLine2DCompound(HandlerNpoints):
+    def create_artists(
+        self,
+        legend: Legend,
+        orig_handle: Artist,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+        trans: Transform,
+    ) -> Sequence[Artist]: ...
+
+class HandlerLine2D(HandlerNpoints):
+    def create_artists(
+        self,
+        legend: Legend,
+        orig_handle: Artist,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+        trans: Transform,
+    ) -> Sequence[Artist]: ...
+
+class HandlerPatch(HandlerBase):
+    def __init__(self, patch_func: Callable | None = ..., **kwargs) -> None: ...
+    def create_artists(
+        self,
+        legend: Legend,
+        orig_handle: Artist,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+        trans: Transform,
+    ) -> Sequence[Artist]: ...
+
+class HandlerStepPatch(HandlerBase):
+    def create_artists(
+        self,
+        legend: Legend,
+        orig_handle: Artist,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+        trans: Transform,
+    ) -> Sequence[Artist]: ...
+
+class HandlerLineCollection(HandlerLine2D):
+    def get_numpoints(self, legend: Legend) -> int: ...
+    def create_artists(
+        self,
+        legend: Legend,
+        orig_handle: Artist,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+        trans: Transform,
+    ) -> Sequence[Artist]: ...
+
+_T = TypeVar("_T", bound=Artist)
+
+class HandlerRegularPolyCollection(HandlerNpointsYoffsets):
+    def __init__(
+        self,
+        yoffsets: Sequence[float] | None = ...,
+        sizes: Sequence[float] | None = ...,
+        **kwargs
+    ) -> None: ...
+    def get_numpoints(self, legend: Legend) -> int: ...
+    def get_sizes(
+        self,
+        legend: Legend,
+        orig_handle: Artist,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+    ) -> Sequence[float]: ...
+    def update_prop(
+        self, legend_handle, orig_handle: Artist, legend: Legend
+    ) -> None: ...
+    def create_collection(
+        self,
+        orig_handle: _T,
+        sizes: Sequence[float] | None,
+        offsets: Sequence[float] | None,
+        offset_transform: Transform,
+    ) -> _T: ...
+    def create_artists(
+        self,
+        legend: Legend,
+        orig_handle: Artist,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+        trans: Transform,
+    ) -> Sequence[Artist]: ...
+
+class HandlerPathCollection(HandlerRegularPolyCollection):
+    def create_collection(
+        self,
+        orig_handle: _T,
+        sizes: Sequence[float] | None,
+        offsets: Sequence[float] | None,
+        offset_transform: Transform,
+    ) -> _T: ...
+
+class HandlerCircleCollection(HandlerRegularPolyCollection):
+    def create_collection(
+        self,
+        orig_handle: _T,
+        sizes: Sequence[float] | None,
+        offsets: Sequence[float] | None,
+        offset_transform: Transform,
+    ) -> _T: ...
+
+class HandlerErrorbar(HandlerLine2D):
+    def __init__(
+        self,
+        xerr_size: float = ...,
+        yerr_size: float | None = ...,
+        marker_pad: float = ...,
+        numpoints: int | None = ...,
+        **kwargs
+    ) -> None: ...
+    def get_err_size(
+        self,
+        legend: Legend,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+    ) -> tuple[float, float]: ...
+    def create_artists(
+        self,
+        legend: Legend,
+        orig_handle: Artist,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+        trans: Transform,
+    ) -> Sequence[Artist]: ...
+
+class HandlerStem(HandlerNpointsYoffsets):
+    def __init__(
+        self,
+        marker_pad: float = ...,
+        numpoints: int | None = ...,
+        bottom: float | None = ...,
+        yoffsets: Sequence[float] | None = ...,
+        **kwargs
+    ) -> None: ...
+    def get_ydata(
+        self,
+        legend: Legend,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+    ) -> ArrayLike: ...
+    def create_artists(
+        self,
+        legend: Legend,
+        orig_handle: Artist,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+        trans: Transform,
+    ) -> Sequence[Artist]: ...
+
+class HandlerTuple(HandlerBase):
+    def __init__(
+        self, ndivide: int | None = ..., pad: float | None = ..., **kwargs
+    ) -> None: ...
+    def create_artists(
+        self,
+        legend: Legend,
+        orig_handle: Artist,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+        trans: Transform,
+    ) -> Sequence[Artist]: ...
+
+class HandlerPolyCollection(HandlerBase):
+    def create_artists(
+        self,
+        legend: Legend,
+        orig_handle: Artist,
+        xdescent: float,
+        ydescent: float,
+        width: float,
+        height: float,
+        fontsize: float,
+        trans: Transform,
+    ) -> Sequence[Artist]: ...

infer_4_30_0/lib/python3.10/site-packages/matplotlib/lines.py

@@ -0,0 +1,1706 @@
+"""
+2D lines with support for a variety of line styles, markers, colors, etc.
+"""
+
+import copy
+
+from numbers import Integral, Number, Real
+import logging
+
+import numpy as np
+
+import matplotlib as mpl
+from . import _api, cbook, colors as mcolors, _docstring
+from .artist import Artist, allow_rasterization
+from .cbook import (
+    _to_unmasked_float_array, ls_mapper, ls_mapper_r, STEP_LOOKUP_MAP)
+from .markers import MarkerStyle
+from .path import Path
+from .transforms import Bbox, BboxTransformTo, TransformedPath
+from ._enums import JoinStyle, CapStyle
+
+# Imported here for backward compatibility, even though they don't
+# really belong.
+from . import _path
+from .markers import (  # noqa
+    CARETLEFT, CARETRIGHT, CARETUP, CARETDOWN,
+    CARETLEFTBASE, CARETRIGHTBASE, CARETUPBASE, CARETDOWNBASE,
+    TICKLEFT, TICKRIGHT, TICKUP, TICKDOWN)
+
+_log = logging.getLogger(__name__)
+
+
+def _get_dash_pattern(style):
+    """Convert linestyle to dash pattern."""
+    # go from short hand -> full strings
+    if isinstance(style, str):
+        style = ls_mapper.get(style, style)
+    # un-dashed styles
+    if style in ['solid', 'None']:
+        offset = 0
+        dashes = None
+    # dashed styles
+    elif style in ['dashed', 'dashdot', 'dotted']:
+        offset = 0
+        dashes = tuple(mpl.rcParams[f'lines.{style}_pattern'])
+    #
+    elif isinstance(style, tuple):
+        offset, dashes = style
+        if offset is None:
+            raise ValueError(f'Unrecognized linestyle: {style!r}')
+    else:
+        raise ValueError(f'Unrecognized linestyle: {style!r}')
+
+    # normalize offset to be positive and shorter than the dash cycle
+    if dashes is not None:
+        dsum = sum(dashes)
+        if dsum:
+            offset %= dsum
+
+    return offset, dashes
+
+
+def _get_inverse_dash_pattern(offset, dashes):
+    """Return the inverse of the given dash pattern, for filling the gaps."""
+    # Define the inverse pattern by moving the last gap to the start of the
+    # sequence.
+    gaps = dashes[-1:] + dashes[:-1]
+    # Set the offset so that this new first segment is skipped
+    # (see backend_bases.GraphicsContextBase.set_dashes for offset definition).
+    offset_gaps = offset + dashes[-1]
+
+    return offset_gaps, gaps
+
+
+def _scale_dashes(offset, dashes, lw):
+    if not mpl.rcParams['lines.scale_dashes']:
+        return offset, dashes
+    scaled_offset = offset * lw
+    scaled_dashes = ([x * lw if x is not None else None for x in dashes]
+                     if dashes is not None else None)
+    return scaled_offset, scaled_dashes
+
+
+def segment_hits(cx, cy, x, y, radius):
+    """
+    Return the indices of the segments in the polyline with coordinates (*cx*,
+    *cy*) that are within a distance *radius* of the point (*x*, *y*).
+    """
+    # Process single points specially
+    if len(x) <= 1:
+        res, = np.nonzero((cx - x) ** 2 + (cy - y) ** 2 <= radius ** 2)
+        return res
+
+    # We need to lop the last element off a lot.
+    xr, yr = x[:-1], y[:-1]
+
+    # Only look at line segments whose nearest point to C on the line
+    # lies within the segment.
+    dx, dy = x[1:] - xr, y[1:] - yr
+    Lnorm_sq = dx ** 2 + dy ** 2  # Possibly want to eliminate Lnorm==0
+    u = ((cx - xr) * dx + (cy - yr) * dy) / Lnorm_sq
+    candidates = (u >= 0) & (u <= 1)
+
+    # Note that there is a little area near one side of each point
+    # which will be near neither segment, and another which will
+    # be near both, depending on the angle of the lines.  The
+    # following radius test eliminates these ambiguities.
+    point_hits = (cx - x) ** 2 + (cy - y) ** 2 <= radius ** 2
+    candidates = candidates & ~(point_hits[:-1] | point_hits[1:])
+
+    # For those candidates which remain, determine how far they lie away
+    # from the line.
+    px, py = xr + u * dx, yr + u * dy
+    line_hits = (cx - px) ** 2 + (cy - py) ** 2 <= radius ** 2
+    line_hits = line_hits & candidates
+    points, = point_hits.ravel().nonzero()
+    lines, = line_hits.ravel().nonzero()
+    return np.concatenate((points, lines))
+
+
+def _mark_every_path(markevery, tpath, affine, ax):
+    """
+    Helper function that sorts out how to deal the input
+    `markevery` and returns the points where markers should be drawn.
+
+    Takes in the `markevery` value and the line path and returns the
+    sub-sampled path.
+    """
+    # pull out the two bits of data we want from the path
+    codes, verts = tpath.codes, tpath.vertices
+
+    def _slice_or_none(in_v, slc):
+        """Helper function to cope with `codes` being an ndarray or `None`."""
+        if in_v is None:
+            return None
+        return in_v[slc]
+
+    # if just an int, assume starting at 0 and make a tuple
+    if isinstance(markevery, Integral):
+        markevery = (0, markevery)
+    # if just a float, assume starting at 0.0 and make a tuple
+    elif isinstance(markevery, Real):
+        markevery = (0.0, markevery)
+
+    if isinstance(markevery, tuple):
+        if len(markevery) != 2:
+            raise ValueError('`markevery` is a tuple but its len is not 2; '
+                             f'markevery={markevery}')
+        start, step = markevery
+        # if step is an int, old behavior
+        if isinstance(step, Integral):
+            # tuple of 2 int is for backwards compatibility,
+            if not isinstance(start, Integral):
+                raise ValueError(
+                    '`markevery` is a tuple with len 2 and second element is '
+                    'an int, but the first element is not an int; '
+                    f'markevery={markevery}')
+            # just return, we are done here
+
+            return Path(verts[slice(start, None, step)],
+                        _slice_or_none(codes, slice(start, None, step)))
+
+        elif isinstance(step, Real):
+            if not isinstance(start, Real):
+                raise ValueError(
+                    '`markevery` is a tuple with len 2 and second element is '
+                    'a float, but the first element is not a float or an int; '
+                    f'markevery={markevery}')
+            if ax is None:
+                raise ValueError(
+                    "markevery is specified relative to the Axes size, but "
+                    "the line does not have a Axes as parent")
+
+            # calc cumulative distance along path (in display coords):
+            fin = np.isfinite(verts).all(axis=1)
+            fverts = verts[fin]
+            disp_coords = affine.transform(fverts)
+
+            delta = np.empty((len(disp_coords), 2))
+            delta[0, :] = 0
+            delta[1:, :] = disp_coords[1:, :] - disp_coords[:-1, :]
+            delta = np.hypot(*delta.T).cumsum()
+            # calc distance between markers along path based on the Axes
+            # bounding box diagonal being a distance of unity:
+            (x0, y0), (x1, y1) = ax.transAxes.transform([[0, 0], [1, 1]])
+            scale = np.hypot(x1 - x0, y1 - y0)
+            marker_delta = np.arange(start * scale, delta[-1], step * scale)
+            # find closest actual data point that is closest to
+            # the theoretical distance along the path:
+            inds = np.abs(delta[np.newaxis, :] - marker_delta[:, np.newaxis])
+            inds = inds.argmin(axis=1)
+            inds = np.unique(inds)
+            # return, we are done here
+            return Path(fverts[inds], _slice_or_none(codes, inds))
+        else:
+            raise ValueError(
+                f"markevery={markevery!r} is a tuple with len 2, but its "
+                f"second element is not an int or a float")
+
+    elif isinstance(markevery, slice):
+        # mazol tov, it's already a slice, just return
+        return Path(verts[markevery], _slice_or_none(codes, markevery))
+
+    elif np.iterable(markevery):
+        # fancy indexing
+        try:
+            return Path(verts[markevery], _slice_or_none(codes, markevery))
+        except (ValueError, IndexError) as err:
+            raise ValueError(
+                f"markevery={markevery!r} is iterable but not a valid numpy "
+                f"fancy index") from err
+    else:
+        raise ValueError(f"markevery={markevery!r} is not a recognized value")
+
+
+@_docstring.interpd
+@_api.define_aliases({
+    "antialiased": ["aa"],
+    "color": ["c"],
+    "drawstyle": ["ds"],
+    "linestyle": ["ls"],
+    "linewidth": ["lw"],
+    "markeredgecolor": ["mec"],
+    "markeredgewidth": ["mew"],
+    "markerfacecolor": ["mfc"],
+    "markerfacecoloralt": ["mfcalt"],
+    "markersize": ["ms"],
+})
+class Line2D(Artist):
+    """
+    A line - the line can have both a solid linestyle connecting all
+    the vertices, and a marker at each vertex.  Additionally, the
+    drawing of the solid line is influenced by the drawstyle, e.g., one
+    can create "stepped" lines in various styles.
+    """
+
+    lineStyles = _lineStyles = {  # hidden names deprecated
+        '-':    '_draw_solid',
+        '--':   '_draw_dashed',
+        '-.':   '_draw_dash_dot',
+        ':':    '_draw_dotted',
+        'None': '_draw_nothing',
+        ' ':    '_draw_nothing',
+        '':     '_draw_nothing',
+    }
+
+    _drawStyles_l = {
+        'default':    '_draw_lines',
+        'steps-mid':  '_draw_steps_mid',
+        'steps-pre':  '_draw_steps_pre',
+        'steps-post': '_draw_steps_post',
+    }
+
+    _drawStyles_s = {
+        'steps': '_draw_steps_pre',
+    }
+
+    # drawStyles should now be deprecated.
+    drawStyles = {**_drawStyles_l, **_drawStyles_s}
+    # Need a list ordered with long names first:
+    drawStyleKeys = [*_drawStyles_l, *_drawStyles_s]
+
+    # Referenced here to maintain API.  These are defined in
+    # MarkerStyle
+    markers = MarkerStyle.markers
+    filled_markers = MarkerStyle.filled_markers
+    fillStyles = MarkerStyle.fillstyles
+
+    zorder = 2
+
+    _subslice_optim_min_size = 1000
+
+    def __str__(self):
+        if self._label != "":
+            return f"Line2D({self._label})"
+        elif self._x is None:
+            return "Line2D()"
+        elif len(self._x) > 3:
+            return "Line2D(({:g},{:g}),({:g},{:g}),...,({:g},{:g}))".format(
+                self._x[0], self._y[0],
+                self._x[1], self._y[1],
+                self._x[-1], self._y[-1])
+        else:
+            return "Line2D(%s)" % ",".join(
+                map("({:g},{:g})".format, self._x, self._y))
+
+    def __init__(self, xdata, ydata, *,
+                 linewidth=None,  # all Nones default to rc
+                 linestyle=None,
+                 color=None,
+                 gapcolor=None,
+                 marker=None,
+                 markersize=None,
+                 markeredgewidth=None,
+                 markeredgecolor=None,
+                 markerfacecolor=None,
+                 markerfacecoloralt='none',
+                 fillstyle=None,
+                 antialiased=None,
+                 dash_capstyle=None,
+                 solid_capstyle=None,
+                 dash_joinstyle=None,
+                 solid_joinstyle=None,
+                 pickradius=5,
+                 drawstyle=None,
+                 markevery=None,
+                 **kwargs
+                 ):
+        """
+        Create a `.Line2D` instance with *x* and *y* data in sequences of
+        *xdata*, *ydata*.
+
+        Additional keyword arguments are `.Line2D` properties:
+
+        %(Line2D:kwdoc)s
+
+        See :meth:`set_linestyle` for a description of the line styles,
+        :meth:`set_marker` for a description of the markers, and
+        :meth:`set_drawstyle` for a description of the draw styles.
+
+        """
+        super().__init__()
+
+        # Convert sequences to NumPy arrays.
+        if not np.iterable(xdata):
+            raise RuntimeError('xdata must be a sequence')
+        if not np.iterable(ydata):
+            raise RuntimeError('ydata must be a sequence')
+
+        if linewidth is None:
+            linewidth = mpl.rcParams['lines.linewidth']
+
+        if linestyle is None:
+            linestyle = mpl.rcParams['lines.linestyle']
+        if marker is None:
+            marker = mpl.rcParams['lines.marker']
+        if color is None:
+            color = mpl.rcParams['lines.color']
+
+        if markersize is None:
+            markersize = mpl.rcParams['lines.markersize']
+        if antialiased is None:
+            antialiased = mpl.rcParams['lines.antialiased']
+        if dash_capstyle is None:
+            dash_capstyle = mpl.rcParams['lines.dash_capstyle']
+        if dash_joinstyle is None:
+            dash_joinstyle = mpl.rcParams['lines.dash_joinstyle']
+        if solid_capstyle is None:
+            solid_capstyle = mpl.rcParams['lines.solid_capstyle']
+        if solid_joinstyle is None:
+            solid_joinstyle = mpl.rcParams['lines.solid_joinstyle']
+
+        if drawstyle is None:
+            drawstyle = 'default'
+
+        self._dashcapstyle = None
+        self._dashjoinstyle = None
+        self._solidjoinstyle = None
+        self._solidcapstyle = None
+        self.set_dash_capstyle(dash_capstyle)
+        self.set_dash_joinstyle(dash_joinstyle)
+        self.set_solid_capstyle(solid_capstyle)
+        self.set_solid_joinstyle(solid_joinstyle)
+
+        self._linestyles = None
+        self._drawstyle = None
+        self._linewidth = linewidth
+        self._unscaled_dash_pattern = (0, None)  # offset, dash
+        self._dash_pattern = (0, None)  # offset, dash (scaled by linewidth)
+
+        self.set_linewidth(linewidth)
+        self.set_linestyle(linestyle)
+        self.set_drawstyle(drawstyle)
+
+        self._color = None
+        self.set_color(color)
+        if marker is None:
+            marker = 'none'  # Default.
+        if not isinstance(marker, MarkerStyle):
+            self._marker = MarkerStyle(marker, fillstyle)
+        else:
+            self._marker = marker
+
+        self._gapcolor = None
+        self.set_gapcolor(gapcolor)
+
+        self._markevery = None
+        self._markersize = None
+        self._antialiased = None
+
+        self.set_markevery(markevery)
+        self.set_antialiased(antialiased)
+        self.set_markersize(markersize)
+
+        self._markeredgecolor = None
+        self._markeredgewidth = None
+        self._markerfacecolor = None
+        self._markerfacecoloralt = None
+
+        self.set_markerfacecolor(markerfacecolor)  # Normalizes None to rc.
+        self.set_markerfacecoloralt(markerfacecoloralt)
+        self.set_markeredgecolor(markeredgecolor)  # Normalizes None to rc.
+        self.set_markeredgewidth(markeredgewidth)
+
+        # update kwargs before updating data to give the caller a
+        # chance to init axes (and hence unit support)
+        self._internal_update(kwargs)
+        self.pickradius = pickradius
+        self.ind_offset = 0
+        if (isinstance(self._picker, Number) and
+                not isinstance(self._picker, bool)):
+            self._pickradius = self._picker
+
+        self._xorig = np.asarray([])
+        self._yorig = np.asarray([])
+        self._invalidx = True
+        self._invalidy = True
+        self._x = None
+        self._y = None
+        self._xy = None
+        self._path = None
+        self._transformed_path = None
+        self._subslice = False
+        self._x_filled = None  # used in subslicing; only x is needed
+
+        self.set_data(xdata, ydata)
+
+    def contains(self, mouseevent):
+        """
+        Test whether *mouseevent* occurred on the line.
+
+        An event is deemed to have occurred "on" the line if it is less
+        than ``self.pickradius`` (default: 5 points) away from it.  Use
+        `~.Line2D.get_pickradius` or `~.Line2D.set_pickradius` to get or set
+        the pick radius.
+
+        Parameters
+        ----------
+        mouseevent : `~matplotlib.backend_bases.MouseEvent`
+
+        Returns
+        -------
+        contains : bool
+            Whether any values are within the radius.
+        details : dict
+            A dictionary ``{'ind': pointlist}``, where *pointlist* is a
+            list of points of the line that are within the pickradius around
+            the event position.
+
+            TODO: sort returned indices by distance
+        """
+        if self._different_canvas(mouseevent):
+            return False, {}
+
+        # Make sure we have data to plot
+        if self._invalidy or self._invalidx:
+            self.recache()
+        if len(self._xy) == 0:
+            return False, {}
+
+        # Convert points to pixels
+        transformed_path = self._get_transformed_path()
+        path, affine = transformed_path.get_transformed_path_and_affine()
+        path = affine.transform_path(path)
+        xy = path.vertices
+        xt = xy[:, 0]
+        yt = xy[:, 1]
+
+        # Convert pick radius from points to pixels
+        fig = self.get_figure(root=True)
+        if fig is None:
+            _log.warning('no figure set when check if mouse is on line')
+            pixels = self._pickradius
+        else:
+            pixels = fig.dpi / 72. * self._pickradius
+
+        # The math involved in checking for containment (here and inside of
+        # segment_hits) assumes that it is OK to overflow, so temporarily set
+        # the error flags accordingly.
+        with np.errstate(all='ignore'):
+            # Check for collision
+            if self._linestyle in ['None', None]:
+                # If no line, return the nearby point(s)
+                ind, = np.nonzero(
+                    (xt - mouseevent.x) ** 2 + (yt - mouseevent.y) ** 2
+                    <= pixels ** 2)
+            else:
+                # If line, return the nearby segment(s)
+                ind = segment_hits(mouseevent.x, mouseevent.y, xt, yt, pixels)
+                if self._drawstyle.startswith("steps"):
+                    ind //= 2
+
+        ind += self.ind_offset
+
+        # Return the point(s) within radius
+        return len(ind) > 0, dict(ind=ind)
+
+    def get_pickradius(self):
+        """
+        Return the pick radius used for containment tests.
+
+        See `.contains` for more details.
+        """
+        return self._pickradius
+
+    def set_pickradius(self, pickradius):
+        """
+        Set the pick radius used for containment tests.
+
+        See `.contains` for more details.
+
+        Parameters
+        ----------
+        pickradius : float
+            Pick radius, in points.
+        """
+        if not isinstance(pickradius, Real) or pickradius < 0:
+            raise ValueError("pick radius should be a distance")
+        self._pickradius = pickradius
+
+    pickradius = property(get_pickradius, set_pickradius)
+
+    def get_fillstyle(self):
+        """
+        Return the marker fill style.
+
+        See also `~.Line2D.set_fillstyle`.
+        """
+        return self._marker.get_fillstyle()
+
+    def set_fillstyle(self, fs):
+        """
+        Set the marker fill style.
+
+        Parameters
+        ----------
+        fs : {'full', 'left', 'right', 'bottom', 'top', 'none'}
+            Possible values:
+
+            - 'full': Fill the whole marker with the *markerfacecolor*.
+            - 'left', 'right', 'bottom', 'top': Fill the marker half at
+              the given side with the *markerfacecolor*. The other
+              half of the marker is filled with *markerfacecoloralt*.
+            - 'none': No filling.
+
+            For examples see :ref:`marker_fill_styles`.
+        """
+        self.set_marker(MarkerStyle(self._marker.get_marker(), fs))
+        self.stale = True
+
+    def set_markevery(self, every):
+        """
+        Set the markevery property to subsample the plot when using markers.
+
+        e.g., if ``every=5``, every 5-th marker will be plotted.
+
+        Parameters
+        ----------
+        every : None or int or (int, int) or slice or list[int] or float or \
+(float, float) or list[bool]
+            Which markers to plot.
+
+            - ``every=None``: every point will be plotted.
+            - ``every=N``: every N-th marker will be plotted starting with
+              marker 0.
+            - ``every=(start, N)``: every N-th marker, starting at index
+              *start*, will be plotted.
+            - ``every=slice(start, end, N)``: every N-th marker, starting at
+              index *start*, up to but not including index *end*, will be
+              plotted.
+            - ``every=[i, j, m, ...]``: only markers at the given indices
+              will be plotted.
+            - ``every=[True, False, True, ...]``: only positions that are True
+              will be plotted. The list must have the same length as the data
+              points.
+            - ``every=0.1``, (i.e. a float): markers will be spaced at
+              approximately equal visual distances along the line; the distance
+              along the line between markers is determined by multiplying the
+              display-coordinate distance of the Axes bounding-box diagonal
+              by the value of *every*.
+            - ``every=(0.5, 0.1)`` (i.e. a length-2 tuple of float): similar
+              to ``every=0.1`` but the first marker will be offset along the
+              line by 0.5 multiplied by the
+              display-coordinate-diagonal-distance along the line.
+
+            For examples see
+            :doc:`/gallery/lines_bars_and_markers/markevery_demo`.
+
+        Notes
+        -----
+        Setting *markevery* will still only draw markers at actual data points.
+        While the float argument form aims for uniform visual spacing, it has
+        to coerce from the ideal spacing to the nearest available data point.
+        Depending on the number and distribution of data points, the result
+        may still not look evenly spaced.
+
+        When using a start offset to specify the first marker, the offset will
+        be from the first data point which may be different from the first
+        the visible data point if the plot is zoomed in.
+
+        If zooming in on a plot when using float arguments then the actual
+        data points that have markers will change because the distance between
+        markers is always determined from the display-coordinates
+        axes-bounding-box-diagonal regardless of the actual axes data limits.
+
+        """
+        self._markevery = every
+        self.stale = True
+
+    def get_markevery(self):
+        """
+        Return the markevery setting for marker subsampling.
+
+        See also `~.Line2D.set_markevery`.
+        """
+        return self._markevery
+
+    def set_picker(self, p):
+        """
+        Set the event picker details for the line.
+
+        Parameters
+        ----------
+        p : float or callable[[Artist, Event], tuple[bool, dict]]
+            If a float, it is used as the pick radius in points.
+        """
+        if not callable(p):
+            self.set_pickradius(p)
+        self._picker = p
+
+    def get_bbox(self):
+        """Get the bounding box of this line."""
+        bbox = Bbox([[0, 0], [0, 0]])
+        bbox.update_from_data_xy(self.get_xydata())
+        return bbox
+
+    def get_window_extent(self, renderer=None):
+        bbox = Bbox([[0, 0], [0, 0]])
+        trans_data_to_xy = self.get_transform().transform
+        bbox.update_from_data_xy(trans_data_to_xy(self.get_xydata()),
+                                 ignore=True)
+        # correct for marker size, if any
+        if self._marker:
+            ms = (self._markersize / 72.0 * self.get_figure(root=True).dpi) * 0.5
+            bbox = bbox.padded(ms)
+        return bbox
+
+    def set_data(self, *args):
+        """
+        Set the x and y data.
+
+        Parameters
+        ----------
+        *args : (2, N) array or two 1D arrays
+
+        See Also
+        --------
+        set_xdata
+        set_ydata
+        """
+        if len(args) == 1:
+            (x, y), = args
+        else:
+            x, y = args
+
+        self.set_xdata(x)
+        self.set_ydata(y)
+
+    def recache_always(self):
+        self.recache(always=True)
+
+    def recache(self, always=False):
+        if always or self._invalidx:
+            xconv = self.convert_xunits(self._xorig)
+            x = _to_unmasked_float_array(xconv).ravel()
+        else:
+            x = self._x
+        if always or self._invalidy:
+            yconv = self.convert_yunits(self._yorig)
+            y = _to_unmasked_float_array(yconv).ravel()
+        else:
+            y = self._y
+
+        self._xy = np.column_stack(np.broadcast_arrays(x, y)).astype(float)
+        self._x, self._y = self._xy.T  # views
+
+        self._subslice = False
+        if (self.axes
+                and len(x) > self._subslice_optim_min_size
+                and _path.is_sorted_and_has_non_nan(x)
+                and self.axes.name == 'rectilinear'
+                and self.axes.get_xscale() == 'linear'
+                and self._markevery is None
+                and self.get_clip_on()
+                and self.get_transform() == self.axes.transData):
+            self._subslice = True
+            nanmask = np.isnan(x)
+            if nanmask.any():
+                self._x_filled = self._x.copy()
+                indices = np.arange(len(x))
+                self._x_filled[nanmask] = np.interp(
+                    indices[nanmask], indices[~nanmask], self._x[~nanmask])
+            else:
+                self._x_filled = self._x
+
+        if self._path is not None:
+            interpolation_steps = self._path._interpolation_steps
+        else:
+            interpolation_steps = 1
+        xy = STEP_LOOKUP_MAP[self._drawstyle](*self._xy.T)
+        self._path = Path(np.asarray(xy).T,
+                          _interpolation_steps=interpolation_steps)
+        self._transformed_path = None
+        self._invalidx = False
+        self._invalidy = False
+
+    def _transform_path(self, subslice=None):
+        """
+        Put a TransformedPath instance at self._transformed_path;
+        all invalidation of the transform is then handled by the
+        TransformedPath instance.
+        """
+        # Masked arrays are now handled by the Path class itself
+        if subslice is not None:
+            xy = STEP_LOOKUP_MAP[self._drawstyle](*self._xy[subslice, :].T)
+            _path = Path(np.asarray(xy).T,
+                         _interpolation_steps=self._path._interpolation_steps)
+        else:
+            _path = self._path
+        self._transformed_path = TransformedPath(_path, self.get_transform())
+
+    def _get_transformed_path(self):
+        """Return this line's `~matplotlib.transforms.TransformedPath`."""
+        if self._transformed_path is None:
+            self._transform_path()
+        return self._transformed_path
+
+    def set_transform(self, t):
+        # docstring inherited
+        self._invalidx = True
+        self._invalidy = True
+        super().set_transform(t)
+
+    @allow_rasterization
+    def draw(self, renderer):
+        # docstring inherited
+
+        if not self.get_visible():
+            return
+
+        if self._invalidy or self._invalidx:
+            self.recache()
+        self.ind_offset = 0  # Needed for contains() method.
+        if self._subslice and self.axes:
+            x0, x1 = self.axes.get_xbound()
+            i0 = self._x_filled.searchsorted(x0, 'left')
+            i1 = self._x_filled.searchsorted(x1, 'right')
+            subslice = slice(max(i0 - 1, 0), i1 + 1)
+            self.ind_offset = subslice.start
+            self._transform_path(subslice)
+        else:
+            subslice = None
+
+        if self.get_path_effects():
+            from matplotlib.patheffects import PathEffectRenderer
+            renderer = PathEffectRenderer(self.get_path_effects(), renderer)
+
+        renderer.open_group('line2d', self.get_gid())
+        if self._lineStyles[self._linestyle] != '_draw_nothing':
+            tpath, affine = (self._get_transformed_path()
+                             .get_transformed_path_and_affine())
+            if len(tpath.vertices):
+                gc = renderer.new_gc()
+                self._set_gc_clip(gc)
+                gc.set_url(self.get_url())
+
+                gc.set_antialiased(self._antialiased)
+                gc.set_linewidth(self._linewidth)
+
+                if self.is_dashed():
+                    cap = self._dashcapstyle
+                    join = self._dashjoinstyle
+                else:
+                    cap = self._solidcapstyle
+                    join = self._solidjoinstyle
+                gc.set_joinstyle(join)
+                gc.set_capstyle(cap)
+                gc.set_snap(self.get_snap())
+                if self.get_sketch_params() is not None:
+                    gc.set_sketch_params(*self.get_sketch_params())
+
+                # We first draw a path within the gaps if needed.
+                if self.is_dashed() and self._gapcolor is not None:
+                    lc_rgba = mcolors.to_rgba(self._gapcolor, self._alpha)
+                    gc.set_foreground(lc_rgba, isRGBA=True)
+
+                    offset_gaps, gaps = _get_inverse_dash_pattern(
+                        *self._dash_pattern)
+
+                    gc.set_dashes(offset_gaps, gaps)
+                    renderer.draw_path(gc, tpath, affine.frozen())
+
+                lc_rgba = mcolors.to_rgba(self._color, self._alpha)
+                gc.set_foreground(lc_rgba, isRGBA=True)
+
+                gc.set_dashes(*self._dash_pattern)
+                renderer.draw_path(gc, tpath, affine.frozen())
+                gc.restore()
+
+        if self._marker and self._markersize > 0:
+            gc = renderer.new_gc()
+            self._set_gc_clip(gc)
+            gc.set_url(self.get_url())
+            gc.set_linewidth(self._markeredgewidth)
+            gc.set_antialiased(self._antialiased)
+
+            ec_rgba = mcolors.to_rgba(
+                self.get_markeredgecolor(), self._alpha)
+            fc_rgba = mcolors.to_rgba(
+                self._get_markerfacecolor(), self._alpha)
+            fcalt_rgba = mcolors.to_rgba(
+                self._get_markerfacecolor(alt=True), self._alpha)
+            # If the edgecolor is "auto", it is set according to the *line*
+            # color but inherits the alpha value of the *face* color, if any.
+            if (cbook._str_equal(self._markeredgecolor, "auto")
+                    and not cbook._str_lower_equal(
+                        self.get_markerfacecolor(), "none")):
+                ec_rgba = ec_rgba[:3] + (fc_rgba[3],)
+            gc.set_foreground(ec_rgba, isRGBA=True)
+            if self.get_sketch_params() is not None:
+                scale, length, randomness = self.get_sketch_params()
+                gc.set_sketch_params(scale/2, length/2, 2*randomness)
+
+            marker = self._marker
+
+            # Markers *must* be drawn ignoring the drawstyle (but don't pay the
+            # recaching if drawstyle is already "default").
+            if self.get_drawstyle() != "default":
+                with cbook._setattr_cm(
+                        self, _drawstyle="default", _transformed_path=None):
+                    self.recache()
+                    self._transform_path(subslice)
+                    tpath, affine = (self._get_transformed_path()
+                                     .get_transformed_points_and_affine())
+            else:
+                tpath, affine = (self._get_transformed_path()
+                                 .get_transformed_points_and_affine())
+
+            if len(tpath.vertices):
+                # subsample the markers if markevery is not None
+                markevery = self.get_markevery()
+                if markevery is not None:
+                    subsampled = _mark_every_path(
+                        markevery, tpath, affine, self.axes)
+                else:
+                    subsampled = tpath
+
+                snap = marker.get_snap_threshold()
+                if isinstance(snap, Real):
+                    snap = renderer.points_to_pixels(self._markersize) >= snap
+                gc.set_snap(snap)
+                gc.set_joinstyle(marker.get_joinstyle())
+                gc.set_capstyle(marker.get_capstyle())
+                marker_path = marker.get_path()
+                marker_trans = marker.get_transform()
+                w = renderer.points_to_pixels(self._markersize)
+
+                if cbook._str_equal(marker.get_marker(), ","):
+                    gc.set_linewidth(0)
+                else:
+                    # Don't scale for pixels, and don't stroke them
+                    marker_trans = marker_trans.scale(w)
+                renderer.draw_markers(gc, marker_path, marker_trans,
+                                      subsampled, affine.frozen(),
+                                      fc_rgba)
+
+                alt_marker_path = marker.get_alt_path()
+                if alt_marker_path:
+                    alt_marker_trans = marker.get_alt_transform()
+                    alt_marker_trans = alt_marker_trans.scale(w)
+                    renderer.draw_markers(
+                            gc, alt_marker_path, alt_marker_trans, subsampled,
+                            affine.frozen(), fcalt_rgba)
+
+            gc.restore()
+
+        renderer.close_group('line2d')
+        self.stale = False
+
+    def get_antialiased(self):
+        """Return whether antialiased rendering is used."""
+        return self._antialiased
+
+    def get_color(self):
+        """
+        Return the line color.
+
+        See also `~.Line2D.set_color`.
+        """
+        return self._color
+
+    def get_drawstyle(self):
+        """
+        Return the drawstyle.
+
+        See also `~.Line2D.set_drawstyle`.
+        """
+        return self._drawstyle
+
+    def get_gapcolor(self):
+        """
+        Return the line gapcolor.
+
+        See also `~.Line2D.set_gapcolor`.
+        """
+        return self._gapcolor
+
+    def get_linestyle(self):
+        """
+        Return the linestyle.
+
+        See also `~.Line2D.set_linestyle`.
+        """
+        return self._linestyle
+
+    def get_linewidth(self):
+        """
+        Return the linewidth in points.
+
+        See also `~.Line2D.set_linewidth`.
+        """
+        return self._linewidth
+
+    def get_marker(self):
+        """
+        Return the line marker.
+
+        See also `~.Line2D.set_marker`.
+        """
+        return self._marker.get_marker()
+
+    def get_markeredgecolor(self):
+        """
+        Return the marker edge color.
+
+        See also `~.Line2D.set_markeredgecolor`.
+        """
+        mec = self._markeredgecolor
+        if cbook._str_equal(mec, 'auto'):
+            if mpl.rcParams['_internal.classic_mode']:
+                if self._marker.get_marker() in ('.', ','):
+                    return self._color
+                if (self._marker.is_filled()
+                        and self._marker.get_fillstyle() != 'none'):
+                    return 'k'  # Bad hard-wired default...
+            return self._color
+        else:
+            return mec
+
+    def get_markeredgewidth(self):
+        """
+        Return the marker edge width in points.
+
+        See also `~.Line2D.set_markeredgewidth`.
+        """
+        return self._markeredgewidth
+
+    def _get_markerfacecolor(self, alt=False):
+        if self._marker.get_fillstyle() == 'none':
+            return 'none'
+        fc = self._markerfacecoloralt if alt else self._markerfacecolor
+        if cbook._str_lower_equal(fc, 'auto'):
+            return self._color
+        else:
+            return fc
+
+    def get_markerfacecolor(self):
+        """
+        Return the marker face color.
+
+        See also `~.Line2D.set_markerfacecolor`.
+        """
+        return self._get_markerfacecolor(alt=False)
+
+    def get_markerfacecoloralt(self):
+        """
+        Return the alternate marker face color.
+
+        See also `~.Line2D.set_markerfacecoloralt`.
+        """
+        return self._get_markerfacecolor(alt=True)
+
+    def get_markersize(self):
+        """
+        Return the marker size in points.
+
+        See also `~.Line2D.set_markersize`.
+        """
+        return self._markersize
+
+    def get_data(self, orig=True):
+        """
+        Return the line data as an ``(xdata, ydata)`` pair.
+
+        If *orig* is *True*, return the original data.
+        """
+        return self.get_xdata(orig=orig), self.get_ydata(orig=orig)
+
+    def get_xdata(self, orig=True):
+        """
+        Return the xdata.
+
+        If *orig* is *True*, return the original data, else the
+        processed data.
+        """
+        if orig:
+            return self._xorig
+        if self._invalidx:
+            self.recache()
+        return self._x
+
+    def get_ydata(self, orig=True):
+        """
+        Return the ydata.
+
+        If *orig* is *True*, return the original data, else the
+        processed data.
+        """
+        if orig:
+            return self._yorig
+        if self._invalidy:
+            self.recache()
+        return self._y
+
+    def get_path(self):
+        """Return the `~matplotlib.path.Path` associated with this line."""
+        if self._invalidy or self._invalidx:
+            self.recache()
+        return self._path
+
+    def get_xydata(self):
+        """Return the *xy* data as a (N, 2) array."""
+        if self._invalidy or self._invalidx:
+            self.recache()
+        return self._xy
+
+    def set_antialiased(self, b):
+        """
+        Set whether to use antialiased rendering.
+
+        Parameters
+        ----------
+        b : bool
+        """
+        if self._antialiased != b:
+            self.stale = True
+        self._antialiased = b
+
+    def set_color(self, color):
+        """
+        Set the color of the line.
+
+        Parameters
+        ----------
+        color : :mpltype:`color`
+        """
+        mcolors._check_color_like(color=color)
+        self._color = color
+        self.stale = True
+
+    def set_drawstyle(self, drawstyle):
+        """
+        Set the drawstyle of the plot.
+
+        The drawstyle determines how the points are connected.
+
+        Parameters
+        ----------
+        drawstyle : {'default', 'steps', 'steps-pre', 'steps-mid', \
+'steps-post'}, default: 'default'
+            For 'default', the points are connected with straight lines.
+
+            The steps variants connect the points with step-like lines,
+            i.e. horizontal lines with vertical steps. They differ in the
+            location of the step:
+
+            - 'steps-pre': The step is at the beginning of the line segment,
+              i.e. the line will be at the y-value of point to the right.
+            - 'steps-mid': The step is halfway between the points.
+            - 'steps-post: The step is at the end of the line segment,
+              i.e. the line will be at the y-value of the point to the left.
+            - 'steps' is equal to 'steps-pre' and is maintained for
+              backward-compatibility.
+
+            For examples see :doc:`/gallery/lines_bars_and_markers/step_demo`.
+        """
+        if drawstyle is None:
+            drawstyle = 'default'
+        _api.check_in_list(self.drawStyles, drawstyle=drawstyle)
+        if self._drawstyle != drawstyle:
+            self.stale = True
+            # invalidate to trigger a recache of the path
+            self._invalidx = True
+        self._drawstyle = drawstyle
+
+    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 None
+            The color with which to fill the gaps. If None, the gaps are
+            unfilled.
+        """
+        if gapcolor is not None:
+            mcolors._check_color_like(color=gapcolor)
+        self._gapcolor = gapcolor
+        self.stale = True
+
+    def set_linewidth(self, w):
+        """
+        Set the line width in points.
+
+        Parameters
+        ----------
+        w : float
+            Line width, in points.
+        """
+        w = float(w)
+        if self._linewidth != w:
+            self.stale = True
+        self._linewidth = w
+        self._dash_pattern = _scale_dashes(*self._unscaled_dash_pattern, w)
+
+    def set_linestyle(self, ls):
+        """
+        Set the linestyle of the line.
+
+        Parameters
+        ----------
+        ls : {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
+            Possible values:
+
+            - A string:
+
+              ==========================================  =================
+              linestyle                                   description
+              ==========================================  =================
+              ``'-'`` or ``'solid'``                      solid line
+              ``'--'`` or  ``'dashed'``                   dashed line
+              ``'-.'`` or  ``'dashdot'``                  dash-dotted line
+              ``':'`` or ``'dotted'``                     dotted line
+              ``'none'``, ``'None'``, ``' '``, or ``''``  draw nothing
+              ==========================================  =================
+
+            - 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. See also :meth:`set_dashes`.
+
+            For examples see :doc:`/gallery/lines_bars_and_markers/linestyles`.
+        """
+        if isinstance(ls, str):
+            if ls in [' ', '', 'none']:
+                ls = 'None'
+            _api.check_in_list([*self._lineStyles, *ls_mapper_r], ls=ls)
+            if ls not in self._lineStyles:
+                ls = ls_mapper_r[ls]
+            self._linestyle = ls
+        else:
+            self._linestyle = '--'
+        self._unscaled_dash_pattern = _get_dash_pattern(ls)
+        self._dash_pattern = _scale_dashes(
+            *self._unscaled_dash_pattern, self._linewidth)
+        self.stale = True
+
+    @_docstring.interpd
+    def set_marker(self, marker):
+        """
+        Set the line marker.
+
+        Parameters
+        ----------
+        marker : marker style string, `~.path.Path` or `~.markers.MarkerStyle`
+            See `~matplotlib.markers` for full description of possible
+            arguments.
+        """
+        self._marker = MarkerStyle(marker, self._marker.get_fillstyle())
+        self.stale = True
+
+    def _set_markercolor(self, name, has_rcdefault, val):
+        if val is None:
+            val = mpl.rcParams[f"lines.{name}"] if has_rcdefault else "auto"
+        attr = f"_{name}"
+        current = getattr(self, attr)
+        if current is None:
+            self.stale = True
+        else:
+            neq = current != val
+            # Much faster than `np.any(current != val)` if no arrays are used.
+            if neq.any() if isinstance(neq, np.ndarray) else neq:
+                self.stale = True
+        setattr(self, attr, val)
+
+    def set_markeredgecolor(self, ec):
+        """
+        Set the marker edge color.
+
+        Parameters
+        ----------
+        ec : :mpltype:`color`
+        """
+        self._set_markercolor("markeredgecolor", True, ec)
+
+    def set_markerfacecolor(self, fc):
+        """
+        Set the marker face color.
+
+        Parameters
+        ----------
+        fc : :mpltype:`color`
+        """
+        self._set_markercolor("markerfacecolor", True, fc)
+
+    def set_markerfacecoloralt(self, fc):
+        """
+        Set the alternate marker face color.
+
+        Parameters
+        ----------
+        fc : :mpltype:`color`
+        """
+        self._set_markercolor("markerfacecoloralt", False, fc)
+
+    def set_markeredgewidth(self, ew):
+        """
+        Set the marker edge width in points.
+
+        Parameters
+        ----------
+        ew : float
+             Marker edge width, in points.
+        """
+        if ew is None:
+            ew = mpl.rcParams['lines.markeredgewidth']
+        if self._markeredgewidth != ew:
+            self.stale = True
+        self._markeredgewidth = ew
+
+    def set_markersize(self, sz):
+        """
+        Set the marker size in points.
+
+        Parameters
+        ----------
+        sz : float
+             Marker size, in points.
+        """
+        sz = float(sz)
+        if self._markersize != sz:
+            self.stale = True
+        self._markersize = sz
+
+    def set_xdata(self, x):
+        """
+        Set the data array for x.
+
+        Parameters
+        ----------
+        x : 1D array
+
+        See Also
+        --------
+        set_data
+        set_ydata
+        """
+        if not np.iterable(x):
+            raise RuntimeError('x must be a sequence')
+        self._xorig = copy.copy(x)
+        self._invalidx = True
+        self.stale = True
+
+    def set_ydata(self, y):
+        """
+        Set the data array for y.
+
+        Parameters
+        ----------
+        y : 1D array
+
+        See Also
+        --------
+        set_data
+        set_xdata
+        """
+        if not np.iterable(y):
+            raise RuntimeError('y must be a sequence')
+        self._yorig = copy.copy(y)
+        self._invalidy = True
+        self.stale = True
+
+    def set_dashes(self, seq):
+        """
+        Set the dash sequence.
+
+        The dash sequence is a sequence of floats of even length describing
+        the length of dashes and spaces in points.
+
+        For example, (5, 2, 1, 2) describes a sequence of 5 point and 1 point
+        dashes separated by 2 point spaces.
+
+        See also `~.Line2D.set_gapcolor`, which allows those spaces to be
+        filled with a color.
+
+        Parameters
+        ----------
+        seq : sequence of floats (on/off ink in points) or (None, None)
+            If *seq* is empty or ``(None, None)``, the linestyle will be set
+            to solid.
+        """
+        if seq == (None, None) or len(seq) == 0:
+            self.set_linestyle('-')
+        else:
+            self.set_linestyle((0, seq))
+
+    def update_from(self, other):
+        """Copy properties from *other* to self."""
+        super().update_from(other)
+        self._linestyle = other._linestyle
+        self._linewidth = other._linewidth
+        self._color = other._color
+        self._gapcolor = other._gapcolor
+        self._markersize = other._markersize
+        self._markerfacecolor = other._markerfacecolor
+        self._markerfacecoloralt = other._markerfacecoloralt
+        self._markeredgecolor = other._markeredgecolor
+        self._markeredgewidth = other._markeredgewidth
+        self._unscaled_dash_pattern = other._unscaled_dash_pattern
+        self._dash_pattern = other._dash_pattern
+        self._dashcapstyle = other._dashcapstyle
+        self._dashjoinstyle = other._dashjoinstyle
+        self._solidcapstyle = other._solidcapstyle
+        self._solidjoinstyle = other._solidjoinstyle
+
+        self._linestyle = other._linestyle
+        self._marker = MarkerStyle(marker=other._marker)
+        self._drawstyle = other._drawstyle
+
+    @_docstring.interpd
+    def set_dash_joinstyle(self, s):
+        """
+        How to join segments of the line if it `~Line2D.is_dashed`.
+
+        The default joinstyle is :rc:`lines.dash_joinstyle`.
+
+        Parameters
+        ----------
+        s : `.JoinStyle` or %(JoinStyle)s
+        """
+        js = JoinStyle(s)
+        if self._dashjoinstyle != js:
+            self.stale = True
+        self._dashjoinstyle = js
+
+    @_docstring.interpd
+    def set_solid_joinstyle(self, s):
+        """
+        How to join segments if the line is solid (not `~Line2D.is_dashed`).
+
+        The default joinstyle is :rc:`lines.solid_joinstyle`.
+
+        Parameters
+        ----------
+        s : `.JoinStyle` or %(JoinStyle)s
+        """
+        js = JoinStyle(s)
+        if self._solidjoinstyle != js:
+            self.stale = True
+        self._solidjoinstyle = js
+
+    def get_dash_joinstyle(self):
+        """
+        Return the `.JoinStyle` for dashed lines.
+
+        See also `~.Line2D.set_dash_joinstyle`.
+        """
+        return self._dashjoinstyle.name
+
+    def get_solid_joinstyle(self):
+        """
+        Return the `.JoinStyle` for solid lines.
+
+        See also `~.Line2D.set_solid_joinstyle`.
+        """
+        return self._solidjoinstyle.name
+
+    @_docstring.interpd
+    def set_dash_capstyle(self, s):
+        """
+        How to draw the end caps if the line is `~Line2D.is_dashed`.
+
+        The default capstyle is :rc:`lines.dash_capstyle`.
+
+        Parameters
+        ----------
+        s : `.CapStyle` or %(CapStyle)s
+        """
+        cs = CapStyle(s)
+        if self._dashcapstyle != cs:
+            self.stale = True
+        self._dashcapstyle = cs
+
+    @_docstring.interpd
+    def set_solid_capstyle(self, s):
+        """
+        How to draw the end caps if the line is solid (not `~Line2D.is_dashed`)
+
+        The default capstyle is :rc:`lines.solid_capstyle`.
+
+        Parameters
+        ----------
+        s : `.CapStyle` or %(CapStyle)s
+        """
+        cs = CapStyle(s)
+        if self._solidcapstyle != cs:
+            self.stale = True
+        self._solidcapstyle = cs
+
+    def get_dash_capstyle(self):
+        """
+        Return the `.CapStyle` for dashed lines.
+
+        See also `~.Line2D.set_dash_capstyle`.
+        """
+        return self._dashcapstyle.name
+
+    def get_solid_capstyle(self):
+        """
+        Return the `.CapStyle` for solid lines.
+
+        See also `~.Line2D.set_solid_capstyle`.
+        """
+        return self._solidcapstyle.name
+
+    def is_dashed(self):
+        """
+        Return whether line has a dashed linestyle.
+
+        A custom linestyle is assumed to be dashed, we do not inspect the
+        ``onoffseq`` directly.
+
+        See also `~.Line2D.set_linestyle`.
+        """
+        return self._linestyle in ('--', '-.', ':')
+
+
+class AxLine(Line2D):
+    """
+    A helper class that implements `~.Axes.axline`, by recomputing the artist
+    transform at draw time.
+    """
+
+    def __init__(self, xy1, xy2, slope, **kwargs):
+        """
+        Parameters
+        ----------
+        xy1 : (float, float)
+            The first set of (x, y) coordinates for the line to pass through.
+        xy2 : (float, float) or None
+            The second set of (x, y) coordinates for the line to pass through.
+            Both *xy2* and *slope* must be passed, but one of them must be None.
+        slope : float or None
+            The slope of the line. Both *xy2* and *slope* must be passed, but one of
+            them must be None.
+        """
+        super().__init__([0, 1], [0, 1], **kwargs)
+
+        if (xy2 is None and slope is None or
+                xy2 is not None and slope is not None):
+            raise TypeError(
+                "Exactly one of 'xy2' and 'slope' must be given")
+
+        self._slope = slope
+        self._xy1 = xy1
+        self._xy2 = xy2
+
+    def get_transform(self):
+        ax = self.axes
+        points_transform = self._transform - ax.transData + ax.transScale
+
+        if self._xy2 is not None:
+            # two points were given
+            (x1, y1), (x2, y2) = \
+                points_transform.transform([self._xy1, self._xy2])
+            dx = x2 - x1
+            dy = y2 - y1
+            if dx == 0:
+                if dy == 0:
+                    raise ValueError(
+                        f"Cannot draw a line through two identical points "
+                        f"(x={(x1, x2)}, y={(y1, y2)})")
+                slope = np.inf
+            else:
+                slope = dy / dx
+        else:
+            # one point and a slope were given
+            x1, y1 = points_transform.transform(self._xy1)
+            slope = self._slope
+        (vxlo, vylo), (vxhi, vyhi) = ax.transScale.transform(ax.viewLim)
+        # General case: find intersections with view limits in either
+        # direction, and draw between the middle two points.
+        if slope == 0:
+            start = vxlo, y1
+            stop = vxhi, y1
+        elif np.isinf(slope):
+            start = x1, vylo
+            stop = x1, vyhi
+        else:
+            _, start, stop, _ = sorted([
+                (vxlo, y1 + (vxlo - x1) * slope),
+                (vxhi, y1 + (vxhi - x1) * slope),
+                (x1 + (vylo - y1) / slope, vylo),
+                (x1 + (vyhi - y1) / slope, vyhi),
+            ])
+        return (BboxTransformTo(Bbox([start, stop]))
+                + ax.transLimits + ax.transAxes)
+
+    def draw(self, renderer):
+        self._transformed_path = None  # Force regen.
+        super().draw(renderer)
+
+    def get_xy1(self):
+        """Return the *xy1* value of the line."""
+        return self._xy1
+
+    def get_xy2(self):
+        """Return the *xy2* value of the line."""
+        return self._xy2
+
+    def get_slope(self):
+        """Return the *slope* value of the line."""
+        return self._slope
+
+    def set_xy1(self, *args, **kwargs):
+        """
+        Set the *xy1* value of the line.
+
+        Parameters
+        ----------
+        xy1 : tuple[float, float]
+            Points for the line to pass through.
+        """
+        params = _api.select_matching_signature([
+            lambda self, x, y: locals(), lambda self, xy1: locals(),
+        ], self, *args, **kwargs)
+        if "x" in params:
+            _api.warn_deprecated("3.10", message=(
+                "Passing x and y separately to AxLine.set_xy1 is deprecated since "
+                "%(since)s; pass them as a single tuple instead."))
+            xy1 = params["x"], params["y"]
+        else:
+            xy1 = params["xy1"]
+        self._xy1 = xy1
+
+    def set_xy2(self, *args, **kwargs):
+        """
+        Set the *xy2* value of the line.
+
+        .. note::
+
+            You can only set *xy2* if the line was created using the *xy2*
+            parameter. If the line was created using *slope*, please use
+            `~.AxLine.set_slope`.
+
+        Parameters
+        ----------
+        xy2 : tuple[float, float]
+            Points for the line to pass through.
+        """
+        if self._slope is None:
+            params = _api.select_matching_signature([
+                lambda self, x, y: locals(), lambda self, xy2: locals(),
+            ], self, *args, **kwargs)
+            if "x" in params:
+                _api.warn_deprecated("3.10", message=(
+                    "Passing x and y separately to AxLine.set_xy2 is deprecated since "
+                    "%(since)s; pass them as a single tuple instead."))
+                xy2 = params["x"], params["y"]
+            else:
+                xy2 = params["xy2"]
+            self._xy2 = xy2
+        else:
+            raise ValueError("Cannot set an 'xy2' value while 'slope' is set;"
+                             " they differ but their functionalities overlap")
+
+    def set_slope(self, slope):
+        """
+        Set the *slope* value of the line.
+
+        .. note::
+
+            You can only set *slope* if the line was created using the *slope*
+            parameter. If the line was created using *xy2*, please use
+            `~.AxLine.set_xy2`.
+
+        Parameters
+        ----------
+        slope : float
+            The slope of the line.
+        """
+        if self._xy2 is None:
+            self._slope = slope
+        else:
+            raise ValueError("Cannot set a 'slope' value while 'xy2' is set;"
+                             " they differ but their functionalities overlap")
+
+
+class VertexSelector:
+    """
+    Manage the callbacks to maintain a list of selected vertices for `.Line2D`.
+    Derived classes should override the `process_selected` method to do
+    something with the picks.
+
+    Here is an example which highlights the selected verts with red circles::
+
+        import numpy as np
+        import matplotlib.pyplot as plt
+        import matplotlib.lines as lines
+
+        class HighlightSelected(lines.VertexSelector):
+            def __init__(self, line, fmt='ro', **kwargs):
+                super().__init__(line)
+                self.markers, = self.axes.plot([], [], fmt, **kwargs)
+
+            def process_selected(self, ind, xs, ys):
+                self.markers.set_data(xs, ys)
+                self.canvas.draw()
+
+        fig, ax = plt.subplots()
+        x, y = np.random.rand(2, 30)
+        line, = ax.plot(x, y, 'bs-', picker=5)
+
+        selector = HighlightSelected(line)
+        plt.show()
+    """
+
+    def __init__(self, line):
+        """
+        Parameters
+        ----------
+        line : `~matplotlib.lines.Line2D`
+            The line must already have been added to an `~.axes.Axes` and must
+            have its picker property set.
+        """
+        if line.axes is None:
+            raise RuntimeError('You must first add the line to the Axes')
+        if line.get_picker() is None:
+            raise RuntimeError('You must first set the picker property '
+                               'of the line')
+        self.axes = line.axes
+        self.line = line
+        self.cid = self.canvas.callbacks._connect_picklable(
+            'pick_event', self.onpick)
+        self.ind = set()
+
+    canvas = property(lambda self: self.axes.get_figure(root=True).canvas)
+
+    def process_selected(self, ind, xs, ys):
+        """
+        Default "do nothing" implementation of the `process_selected` method.
+
+        Parameters
+        ----------
+        ind : list of int
+            The indices of the selected vertices.
+        xs, ys : array-like
+            The coordinates of the selected vertices.
+        """
+        pass
+
+    def onpick(self, event):
+        """When the line is picked, update the set of selected indices."""
+        if event.artist is not self.line:
+            return
+        self.ind ^= set(event.ind)
+        ind = sorted(self.ind)
+        xdata, ydata = self.line.get_data()
+        self.process_selected(ind, xdata[ind], ydata[ind])
+
+
+lineStyles = Line2D._lineStyles
+lineMarkers = MarkerStyle.markers
+drawStyles = Line2D.drawStyles
+fillStyles = MarkerStyle.fillstyles

infer_4_30_0/lib/python3.10/site-packages/matplotlib/markers.py

@@ -0,0 +1,908 @@
+r"""
+Functions to handle markers; used by the marker functionality of
+`~matplotlib.axes.Axes.plot`, `~matplotlib.axes.Axes.scatter`, and
+`~matplotlib.axes.Axes.errorbar`.
+
+All possible markers are defined here:
+
+============================== ====== =========================================
+marker                         symbol description
+============================== ====== =========================================
+``"."``                        |m00|  point
+``","``                        |m01|  pixel
+``"o"``                        |m02|  circle
+``"v"``                        |m03|  triangle_down
+``"^"``                        |m04|  triangle_up
+``"<"``                        |m05|  triangle_left
+``">"``                        |m06|  triangle_right
+``"1"``                        |m07|  tri_down
+``"2"``                        |m08|  tri_up
+``"3"``                        |m09|  tri_left
+``"4"``                        |m10|  tri_right
+``"8"``                        |m11|  octagon
+``"s"``                        |m12|  square
+``"p"``                        |m13|  pentagon
+``"P"``                        |m23|  plus (filled)
+``"*"``                        |m14|  star
+``"h"``                        |m15|  hexagon1
+``"H"``                        |m16|  hexagon2
+``"+"``                        |m17|  plus
+``"x"``                        |m18|  x
+``"X"``                        |m24|  x (filled)
+``"D"``                        |m19|  diamond
+``"d"``                        |m20|  thin_diamond
+``"|"``                        |m21|  vline
+``"_"``                        |m22|  hline
+``0`` (``TICKLEFT``)           |m25|  tickleft
+``1`` (``TICKRIGHT``)          |m26|  tickright
+``2`` (``TICKUP``)             |m27|  tickup
+``3`` (``TICKDOWN``)           |m28|  tickdown
+``4`` (``CARETLEFT``)          |m29|  caretleft
+``5`` (``CARETRIGHT``)         |m30|  caretright
+``6`` (``CARETUP``)            |m31|  caretup
+``7`` (``CARETDOWN``)          |m32|  caretdown
+``8`` (``CARETLEFTBASE``)      |m33|  caretleft (centered at base)
+``9`` (``CARETRIGHTBASE``)     |m34|  caretright (centered at base)
+``10`` (``CARETUPBASE``)       |m35|  caretup (centered at base)
+``11`` (``CARETDOWNBASE``)     |m36|  caretdown (centered at base)
+``"none"`` or ``"None"``              nothing
+``" "`` or  ``""``                    nothing
+``"$...$"``                    |m37|  Render the string using mathtext.
+                                      E.g ``"$f$"`` for marker showing the
+                                      letter ``f``.
+``verts``                             A list of (x, y) pairs used for Path
+                                      vertices. The center of the marker is
+                                      located at (0, 0) and the size is
+                                      normalized, such that the created path
+                                      is encapsulated inside the unit cell.
+``path``                              A `~matplotlib.path.Path` instance.
+``(numsides, 0, angle)``              A regular polygon with ``numsides``
+                                      sides, rotated by ``angle``.
+``(numsides, 1, angle)``              A star-like symbol with ``numsides``
+                                      sides, rotated by ``angle``.
+``(numsides, 2, angle)``              An asterisk with ``numsides`` sides,
+                                      rotated by ``angle``.
+============================== ====== =========================================
+
+Note that special symbols can be defined via the
+:ref:`STIX math font <mathtext>`,
+e.g. ``"$\u266B$"``. For an overview over the STIX font symbols refer to the
+`STIX font table <http://www.stixfonts.org/allGlyphs.html>`_.
+Also see the :doc:`/gallery/text_labels_and_annotations/stix_fonts_demo`.
+
+Integer numbers from ``0`` to ``11`` create lines and triangles. Those are
+equally accessible via capitalized variables, like ``CARETDOWNBASE``.
+Hence the following are equivalent::
+
+    plt.plot([1, 2, 3], marker=11)
+    plt.plot([1, 2, 3], marker=matplotlib.markers.CARETDOWNBASE)
+
+Markers join and cap styles can be customized by creating a new instance of
+MarkerStyle.
+A MarkerStyle can also have a custom `~matplotlib.transforms.Transform`
+allowing it to be arbitrarily rotated or offset.
+
+Examples showing the use of markers:
+
+* :doc:`/gallery/lines_bars_and_markers/marker_reference`
+* :doc:`/gallery/lines_bars_and_markers/scatter_star_poly`
+* :doc:`/gallery/lines_bars_and_markers/multivariate_marker_plot`
+
+.. |m00| image:: /_static/markers/m00.png
+.. |m01| image:: /_static/markers/m01.png
+.. |m02| image:: /_static/markers/m02.png
+.. |m03| image:: /_static/markers/m03.png
+.. |m04| image:: /_static/markers/m04.png
+.. |m05| image:: /_static/markers/m05.png
+.. |m06| image:: /_static/markers/m06.png
+.. |m07| image:: /_static/markers/m07.png
+.. |m08| image:: /_static/markers/m08.png
+.. |m09| image:: /_static/markers/m09.png
+.. |m10| image:: /_static/markers/m10.png
+.. |m11| image:: /_static/markers/m11.png
+.. |m12| image:: /_static/markers/m12.png
+.. |m13| image:: /_static/markers/m13.png
+.. |m14| image:: /_static/markers/m14.png
+.. |m15| image:: /_static/markers/m15.png
+.. |m16| image:: /_static/markers/m16.png
+.. |m17| image:: /_static/markers/m17.png
+.. |m18| image:: /_static/markers/m18.png
+.. |m19| image:: /_static/markers/m19.png
+.. |m20| image:: /_static/markers/m20.png
+.. |m21| image:: /_static/markers/m21.png
+.. |m22| image:: /_static/markers/m22.png
+.. |m23| image:: /_static/markers/m23.png
+.. |m24| image:: /_static/markers/m24.png
+.. |m25| image:: /_static/markers/m25.png
+.. |m26| image:: /_static/markers/m26.png
+.. |m27| image:: /_static/markers/m27.png
+.. |m28| image:: /_static/markers/m28.png
+.. |m29| image:: /_static/markers/m29.png
+.. |m30| image:: /_static/markers/m30.png
+.. |m31| image:: /_static/markers/m31.png
+.. |m32| image:: /_static/markers/m32.png
+.. |m33| image:: /_static/markers/m33.png
+.. |m34| image:: /_static/markers/m34.png
+.. |m35| image:: /_static/markers/m35.png
+.. |m36| image:: /_static/markers/m36.png
+.. |m37| image:: /_static/markers/m37.png
+"""
+import copy
+
+from collections.abc import Sized
+
+import numpy as np
+
+import matplotlib as mpl
+from . import _api, cbook
+from .path import Path
+from .transforms import IdentityTransform, Affine2D
+from ._enums import JoinStyle, CapStyle
+
+# special-purpose marker identifiers:
+(TICKLEFT, TICKRIGHT, TICKUP, TICKDOWN,
+ CARETLEFT, CARETRIGHT, CARETUP, CARETDOWN,
+ CARETLEFTBASE, CARETRIGHTBASE, CARETUPBASE, CARETDOWNBASE) = range(12)
+
+_empty_path = Path(np.empty((0, 2)))
+
+
+class MarkerStyle:
+    """
+    A class representing marker types.
+
+    Instances are immutable. If you need to change anything, create a new
+    instance.
+
+    Attributes
+    ----------
+    markers : dict
+        All known markers.
+    filled_markers : tuple
+        All known filled markers. This is a subset of *markers*.
+    fillstyles : tuple
+        The supported fillstyles.
+    """
+
+    markers = {
+        '.': 'point',
+        ',': 'pixel',
+        'o': 'circle',
+        'v': 'triangle_down',
+        '^': 'triangle_up',
+        '<': 'triangle_left',
+        '>': 'triangle_right',
+        '1': 'tri_down',
+        '2': 'tri_up',
+        '3': 'tri_left',
+        '4': 'tri_right',
+        '8': 'octagon',
+        's': 'square',
+        'p': 'pentagon',
+        '*': 'star',
+        'h': 'hexagon1',
+        'H': 'hexagon2',
+        '+': 'plus',
+        'x': 'x',
+        'D': 'diamond',
+        'd': 'thin_diamond',
+        '|': 'vline',
+        '_': 'hline',
+        'P': 'plus_filled',
+        'X': 'x_filled',
+        TICKLEFT: 'tickleft',
+        TICKRIGHT: 'tickright',
+        TICKUP: 'tickup',
+        TICKDOWN: 'tickdown',
+        CARETLEFT: 'caretleft',
+        CARETRIGHT: 'caretright',
+        CARETUP: 'caretup',
+        CARETDOWN: 'caretdown',
+        CARETLEFTBASE: 'caretleftbase',
+        CARETRIGHTBASE: 'caretrightbase',
+        CARETUPBASE: 'caretupbase',
+        CARETDOWNBASE: 'caretdownbase',
+        "None": 'nothing',
+        "none": 'nothing',
+        ' ': 'nothing',
+        '': 'nothing'
+    }
+
+    # Just used for informational purposes.  is_filled()
+    # is calculated in the _set_* functions.
+    filled_markers = (
+        '.', 'o', 'v', '^', '<', '>', '8', 's', 'p', '*', 'h', 'H', 'D', 'd',
+        'P', 'X')
+
+    fillstyles = ('full', 'left', 'right', 'bottom', 'top', 'none')
+    _half_fillstyles = ('left', 'right', 'bottom', 'top')
+
+    def __init__(self, marker,
+                 fillstyle=None, transform=None, capstyle=None, joinstyle=None):
+        """
+        Parameters
+        ----------
+        marker : str, array-like, Path, MarkerStyle
+            - Another instance of `MarkerStyle` copies the details of that *marker*.
+            - For other possible marker values, see the module docstring
+              `matplotlib.markers`.
+
+        fillstyle : str, default: :rc:`markers.fillstyle`
+            One of 'full', 'left', 'right', 'bottom', 'top', 'none'.
+
+        transform : `~matplotlib.transforms.Transform`, optional
+            Transform that will be combined with the native transform of the
+            marker.
+
+        capstyle : `.CapStyle` or %(CapStyle)s, optional
+            Cap style that will override the default cap style of the marker.
+
+        joinstyle : `.JoinStyle` or %(JoinStyle)s, optional
+            Join style that will override the default join style of the marker.
+        """
+        self._marker_function = None
+        self._user_transform = transform
+        self._user_capstyle = CapStyle(capstyle) if capstyle is not None else None
+        self._user_joinstyle = JoinStyle(joinstyle) if joinstyle is not None else None
+        self._set_fillstyle(fillstyle)
+        self._set_marker(marker)
+
+    def _recache(self):
+        if self._marker_function is None:
+            return
+        self._path = _empty_path
+        self._transform = IdentityTransform()
+        self._alt_path = None
+        self._alt_transform = None
+        self._snap_threshold = None
+        self._joinstyle = JoinStyle.round
+        self._capstyle = self._user_capstyle or CapStyle.butt
+        # Initial guess: Assume the marker is filled unless the fillstyle is
+        # set to 'none'. The marker function will override this for unfilled
+        # markers.
+        self._filled = self._fillstyle != 'none'
+        self._marker_function()
+
+    def __bool__(self):
+        return bool(len(self._path.vertices))
+
+    def is_filled(self):
+        return self._filled
+
+    def get_fillstyle(self):
+        return self._fillstyle
+
+    def _set_fillstyle(self, fillstyle):
+        """
+        Set the fillstyle.
+
+        Parameters
+        ----------
+        fillstyle : {'full', 'left', 'right', 'bottom', 'top', 'none'}
+            The part of the marker surface that is colored with
+            markerfacecolor.
+        """
+        if fillstyle is None:
+            fillstyle = mpl.rcParams['markers.fillstyle']
+        _api.check_in_list(self.fillstyles, fillstyle=fillstyle)
+        self._fillstyle = fillstyle
+
+    def get_joinstyle(self):
+        return self._joinstyle.name
+
+    def get_capstyle(self):
+        return self._capstyle.name
+
+    def get_marker(self):
+        return self._marker
+
+    def _set_marker(self, marker):
+        """
+        Set the marker.
+
+        Parameters
+        ----------
+        marker : str, array-like, Path, MarkerStyle
+            - Another instance of `MarkerStyle` copies the details of that *marker*.
+            - For other possible marker values see the module docstring
+              `matplotlib.markers`.
+        """
+        if isinstance(marker, str) and cbook.is_math_text(marker):
+            self._marker_function = self._set_mathtext_path
+        elif isinstance(marker, (int, str)) and marker in self.markers:
+            self._marker_function = getattr(self, '_set_' + self.markers[marker])
+        elif (isinstance(marker, np.ndarray) and marker.ndim == 2 and
+                marker.shape[1] == 2):
+            self._marker_function = self._set_vertices
+        elif isinstance(marker, Path):
+            self._marker_function = self._set_path_marker
+        elif (isinstance(marker, Sized) and len(marker) in (2, 3) and
+                marker[1] in (0, 1, 2)):
+            self._marker_function = self._set_tuple_marker
+        elif isinstance(marker, MarkerStyle):
+            self.__dict__ = copy.deepcopy(marker.__dict__)
+        else:
+            try:
+                Path(marker)
+                self._marker_function = self._set_vertices
+            except ValueError as err:
+                raise ValueError(
+                    f'Unrecognized marker style {marker!r}') from err
+
+        if not isinstance(marker, MarkerStyle):
+            self._marker = marker
+            self._recache()
+
+    def get_path(self):
+        """
+        Return a `.Path` for the primary part of the marker.
+
+        For unfilled markers this is the whole marker, for filled markers,
+        this is the area to be drawn with *markerfacecolor*.
+        """
+        return self._path
+
+    def get_transform(self):
+        """
+        Return the transform to be applied to the `.Path` from
+        `MarkerStyle.get_path()`.
+        """
+        if self._user_transform is None:
+            return self._transform.frozen()
+        else:
+            return (self._transform + self._user_transform).frozen()
+
+    def get_alt_path(self):
+        """
+        Return a `.Path` for the alternate part of the marker.
+
+        For unfilled markers, this is *None*; for filled markers, this is the
+        area to be drawn with *markerfacecoloralt*.
+        """
+        return self._alt_path
+
+    def get_alt_transform(self):
+        """
+        Return the transform to be applied to the `.Path` from
+        `MarkerStyle.get_alt_path()`.
+        """
+        if self._user_transform is None:
+            return self._alt_transform.frozen()
+        else:
+            return (self._alt_transform + self._user_transform).frozen()
+
+    def get_snap_threshold(self):
+        return self._snap_threshold
+
+    def get_user_transform(self):
+        """Return user supplied part of marker transform."""
+        if self._user_transform is not None:
+            return self._user_transform.frozen()
+
+    def transformed(self, transform):
+        """
+        Return a new version of this marker with the transform applied.
+
+        Parameters
+        ----------
+        transform : `~matplotlib.transforms.Affine2D`
+            Transform will be combined with current user supplied transform.
+        """
+        new_marker = MarkerStyle(self)
+        if new_marker._user_transform is not None:
+            new_marker._user_transform += transform
+        else:
+            new_marker._user_transform = transform
+        return new_marker
+
+    def rotated(self, *, deg=None, rad=None):
+        """
+        Return a new version of this marker rotated by specified angle.
+
+        Parameters
+        ----------
+        deg : float, optional
+            Rotation angle in degrees.
+
+        rad : float, optional
+            Rotation angle in radians.
+
+        .. note:: You must specify exactly one of deg or rad.
+        """
+        if deg is None and rad is None:
+            raise ValueError('One of deg or rad is required')
+        if deg is not None and rad is not None:
+            raise ValueError('Only one of deg and rad can be supplied')
+        new_marker = MarkerStyle(self)
+        if new_marker._user_transform is None:
+            new_marker._user_transform = Affine2D()
+
+        if deg is not None:
+            new_marker._user_transform.rotate_deg(deg)
+        if rad is not None:
+            new_marker._user_transform.rotate(rad)
+
+        return new_marker
+
+    def scaled(self, sx, sy=None):
+        """
+        Return new marker scaled by specified scale factors.
+
+        If *sy* is not given, the same scale is applied in both the *x*- and
+        *y*-directions.
+
+        Parameters
+        ----------
+        sx : float
+            *X*-direction scaling factor.
+        sy : float, optional
+            *Y*-direction scaling factor.
+        """
+        if sy is None:
+            sy = sx
+
+        new_marker = MarkerStyle(self)
+        _transform = new_marker._user_transform or Affine2D()
+        new_marker._user_transform = _transform.scale(sx, sy)
+        return new_marker
+
+    def _set_nothing(self):
+        self._filled = False
+
+    def _set_custom_marker(self, path):
+        rescale = np.max(np.abs(path.vertices))  # max of x's and y's.
+        self._transform = Affine2D().scale(0.5 / rescale)
+        self._path = path
+
+    def _set_path_marker(self):
+        self._set_custom_marker(self._marker)
+
+    def _set_vertices(self):
+        self._set_custom_marker(Path(self._marker))
+
+    def _set_tuple_marker(self):
+        marker = self._marker
+        if len(marker) == 2:
+            numsides, rotation = marker[0], 0.0
+        elif len(marker) == 3:
+            numsides, rotation = marker[0], marker[2]
+        symstyle = marker[1]
+        if symstyle == 0:
+            self._path = Path.unit_regular_polygon(numsides)
+            self._joinstyle = self._user_joinstyle or JoinStyle.miter
+        elif symstyle == 1:
+            self._path = Path.unit_regular_star(numsides)
+            self._joinstyle = self._user_joinstyle or JoinStyle.bevel
+        elif symstyle == 2:
+            self._path = Path.unit_regular_asterisk(numsides)
+            self._filled = False
+            self._joinstyle = self._user_joinstyle or JoinStyle.bevel
+        else:
+            raise ValueError(f"Unexpected tuple marker: {marker}")
+        self._transform = Affine2D().scale(0.5).rotate_deg(rotation)
+
+    def _set_mathtext_path(self):
+        """
+        Draw mathtext markers '$...$' using `.TextPath` object.
+
+        Submitted by tcb
+        """
+        from matplotlib.text import TextPath
+
+        # again, the properties could be initialised just once outside
+        # this function
+        text = TextPath(xy=(0, 0), s=self.get_marker(),
+                        usetex=mpl.rcParams['text.usetex'])
+        if len(text.vertices) == 0:
+            return
+
+        bbox = text.get_extents()
+        max_dim = max(bbox.width, bbox.height)
+        self._transform = (
+            Affine2D()
+            .translate(-bbox.xmin + 0.5 * -bbox.width, -bbox.ymin + 0.5 * -bbox.height)
+            .scale(1.0 / max_dim))
+        self._path = text
+        self._snap = False
+
+    def _half_fill(self):
+        return self.get_fillstyle() in self._half_fillstyles
+
+    def _set_circle(self, size=1.0):
+        self._transform = Affine2D().scale(0.5 * size)
+        self._snap_threshold = np.inf
+        if not self._half_fill():
+            self._path = Path.unit_circle()
+        else:
+            self._path = self._alt_path = Path.unit_circle_righthalf()
+            fs = self.get_fillstyle()
+            self._transform.rotate_deg(
+                {'right': 0, 'top': 90, 'left': 180, 'bottom': 270}[fs])
+            self._alt_transform = self._transform.frozen().rotate_deg(180.)
+
+    def _set_point(self):
+        self._set_circle(size=0.5)
+
+    def _set_pixel(self):
+        self._path = Path.unit_rectangle()
+        # Ideally, you'd want -0.5, -0.5 here, but then the snapping
+        # algorithm in the Agg backend will round this to a 2x2
+        # rectangle from (-1, -1) to (1, 1).  By offsetting it
+        # slightly, we can force it to be (0, 0) to (1, 1), which both
+        # makes it only be a single pixel and places it correctly
+        # aligned to 1-width stroking (i.e. the ticks).  This hack is
+        # the best of a number of bad alternatives, mainly because the
+        # backends are not aware of what marker is actually being used
+        # beyond just its path data.
+        self._transform = Affine2D().translate(-0.49999, -0.49999)
+        self._snap_threshold = None
+
+    _triangle_path = Path._create_closed([[0, 1], [-1, -1], [1, -1]])
+    # Going down halfway looks to small.  Golden ratio is too far.
+    _triangle_path_u = Path._create_closed([[0, 1], [-3/5, -1/5], [3/5, -1/5]])
+    _triangle_path_d = Path._create_closed(
+        [[-3/5, -1/5], [3/5, -1/5], [1, -1], [-1, -1]])
+    _triangle_path_l = Path._create_closed([[0, 1], [0, -1], [-1, -1]])
+    _triangle_path_r = Path._create_closed([[0, 1], [0, -1], [1, -1]])
+
+    def _set_triangle(self, rot, skip):
+        self._transform = Affine2D().scale(0.5).rotate_deg(rot)
+        self._snap_threshold = 5.0
+
+        if not self._half_fill():
+            self._path = self._triangle_path
+        else:
+            mpaths = [self._triangle_path_u,
+                      self._triangle_path_l,
+                      self._triangle_path_d,
+                      self._triangle_path_r]
+
+            fs = self.get_fillstyle()
+            if fs == 'top':
+                self._path = mpaths[(0 + skip) % 4]
+                self._alt_path = mpaths[(2 + skip) % 4]
+            elif fs == 'bottom':
+                self._path = mpaths[(2 + skip) % 4]
+                self._alt_path = mpaths[(0 + skip) % 4]
+            elif fs == 'left':
+                self._path = mpaths[(1 + skip) % 4]
+                self._alt_path = mpaths[(3 + skip) % 4]
+            else:
+                self._path = mpaths[(3 + skip) % 4]
+                self._alt_path = mpaths[(1 + skip) % 4]
+
+            self._alt_transform = self._transform
+
+        self._joinstyle = self._user_joinstyle or JoinStyle.miter
+
+    def _set_triangle_up(self):
+        return self._set_triangle(0.0, 0)
+
+    def _set_triangle_down(self):
+        return self._set_triangle(180.0, 2)
+
+    def _set_triangle_left(self):
+        return self._set_triangle(90.0, 3)
+
+    def _set_triangle_right(self):
+        return self._set_triangle(270.0, 1)
+
+    def _set_square(self):
+        self._transform = Affine2D().translate(-0.5, -0.5)
+        self._snap_threshold = 2.0
+        if not self._half_fill():
+            self._path = Path.unit_rectangle()
+        else:
+            # Build a bottom filled square out of two rectangles, one filled.
+            self._path = Path([[0.0, 0.0], [1.0, 0.0], [1.0, 0.5],
+                               [0.0, 0.5], [0.0, 0.0]])
+            self._alt_path = Path([[0.0, 0.5], [1.0, 0.5], [1.0, 1.0],
+                                   [0.0, 1.0], [0.0, 0.5]])
+            fs = self.get_fillstyle()
+            rotate = {'bottom': 0, 'right': 90, 'top': 180, 'left': 270}[fs]
+            self._transform.rotate_deg(rotate)
+            self._alt_transform = self._transform
+
+        self._joinstyle = self._user_joinstyle or JoinStyle.miter
+
+    def _set_diamond(self):
+        self._transform = Affine2D().translate(-0.5, -0.5).rotate_deg(45)
+        self._snap_threshold = 5.0
+        if not self._half_fill():
+            self._path = Path.unit_rectangle()
+        else:
+            self._path = Path([[0, 0], [1, 0], [1, 1], [0, 0]])
+            self._alt_path = Path([[0, 0], [0, 1], [1, 1], [0, 0]])
+            fs = self.get_fillstyle()
+            rotate = {'right': 0, 'top': 90, 'left': 180, 'bottom': 270}[fs]
+            self._transform.rotate_deg(rotate)
+            self._alt_transform = self._transform
+        self._joinstyle = self._user_joinstyle or JoinStyle.miter
+
+    def _set_thin_diamond(self):
+        self._set_diamond()
+        self._transform.scale(0.6, 1.0)
+
+    def _set_pentagon(self):
+        self._transform = Affine2D().scale(0.5)
+        self._snap_threshold = 5.0
+
+        polypath = Path.unit_regular_polygon(5)
+
+        if not self._half_fill():
+            self._path = polypath
+        else:
+            verts = polypath.vertices
+            y = (1 + np.sqrt(5)) / 4.
+            top = Path(verts[[0, 1, 4, 0]])
+            bottom = Path(verts[[1, 2, 3, 4, 1]])
+            left = Path([verts[0], verts[1], verts[2], [0, -y], verts[0]])
+            right = Path([verts[0], verts[4], verts[3], [0, -y], verts[0]])
+            self._path, self._alt_path = {
+                'top': (top, bottom), 'bottom': (bottom, top),
+                'left': (left, right), 'right': (right, left),
+            }[self.get_fillstyle()]
+            self._alt_transform = self._transform
+
+        self._joinstyle = self._user_joinstyle or JoinStyle.miter
+
+    def _set_star(self):
+        self._transform = Affine2D().scale(0.5)
+        self._snap_threshold = 5.0
+
+        polypath = Path.unit_regular_star(5, innerCircle=0.381966)
+
+        if not self._half_fill():
+            self._path = polypath
+        else:
+            verts = polypath.vertices
+            top = Path(np.concatenate([verts[0:4], verts[7:10], verts[0:1]]))
+            bottom = Path(np.concatenate([verts[3:8], verts[3:4]]))
+            left = Path(np.concatenate([verts[0:6], verts[0:1]]))
+            right = Path(np.concatenate([verts[0:1], verts[5:10], verts[0:1]]))
+            self._path, self._alt_path = {
+                'top': (top, bottom), 'bottom': (bottom, top),
+                'left': (left, right), 'right': (right, left),
+            }[self.get_fillstyle()]
+            self._alt_transform = self._transform
+
+        self._joinstyle = self._user_joinstyle or JoinStyle.bevel
+
+    def _set_hexagon1(self):
+        self._transform = Affine2D().scale(0.5)
+        self._snap_threshold = None
+
+        polypath = Path.unit_regular_polygon(6)
+
+        if not self._half_fill():
+            self._path = polypath
+        else:
+            verts = polypath.vertices
+            # not drawing inside lines
+            x = np.abs(np.cos(5 * np.pi / 6.))
+            top = Path(np.concatenate([[(-x, 0)], verts[[1, 0, 5]], [(x, 0)]]))
+            bottom = Path(np.concatenate([[(-x, 0)], verts[2:5], [(x, 0)]]))
+            left = Path(verts[0:4])
+            right = Path(verts[[0, 5, 4, 3]])
+            self._path, self._alt_path = {
+                'top': (top, bottom), 'bottom': (bottom, top),
+                'left': (left, right), 'right': (right, left),
+            }[self.get_fillstyle()]
+            self._alt_transform = self._transform
+
+        self._joinstyle = self._user_joinstyle or JoinStyle.miter
+
+    def _set_hexagon2(self):
+        self._transform = Affine2D().scale(0.5).rotate_deg(30)
+        self._snap_threshold = None
+
+        polypath = Path.unit_regular_polygon(6)
+
+        if not self._half_fill():
+            self._path = polypath
+        else:
+            verts = polypath.vertices
+            # not drawing inside lines
+            x, y = np.sqrt(3) / 4, 3 / 4.
+            top = Path(verts[[1, 0, 5, 4, 1]])
+            bottom = Path(verts[1:5])
+            left = Path(np.concatenate([
+                [(x, y)], verts[:3], [(-x, -y), (x, y)]]))
+            right = Path(np.concatenate([
+                [(x, y)], verts[5:2:-1], [(-x, -y)]]))
+            self._path, self._alt_path = {
+                'top': (top, bottom), 'bottom': (bottom, top),
+                'left': (left, right), 'right': (right, left),
+            }[self.get_fillstyle()]
+            self._alt_transform = self._transform
+
+        self._joinstyle = self._user_joinstyle or JoinStyle.miter
+
+    def _set_octagon(self):
+        self._transform = Affine2D().scale(0.5)
+        self._snap_threshold = 5.0
+
+        polypath = Path.unit_regular_polygon(8)
+
+        if not self._half_fill():
+            self._transform.rotate_deg(22.5)
+            self._path = polypath
+        else:
+            x = np.sqrt(2.) / 4.
+            self._path = self._alt_path = Path(
+                [[0, -1], [0, 1], [-x, 1], [-1, x],
+                 [-1, -x], [-x, -1], [0, -1]])
+            fs = self.get_fillstyle()
+            self._transform.rotate_deg(
+                {'left': 0, 'bottom': 90, 'right': 180, 'top': 270}[fs])
+            self._alt_transform = self._transform.frozen().rotate_deg(180.0)
+
+        self._joinstyle = self._user_joinstyle or JoinStyle.miter
+
+    _line_marker_path = Path([[0.0, -1.0], [0.0, 1.0]])
+
+    def _set_vline(self):
+        self._transform = Affine2D().scale(0.5)
+        self._snap_threshold = 1.0
+        self._filled = False
+        self._path = self._line_marker_path
+
+    def _set_hline(self):
+        self._set_vline()
+        self._transform = self._transform.rotate_deg(90)
+
+    _tickhoriz_path = Path([[0.0, 0.0], [1.0, 0.0]])
+
+    def _set_tickleft(self):
+        self._transform = Affine2D().scale(-1.0, 1.0)
+        self._snap_threshold = 1.0
+        self._filled = False
+        self._path = self._tickhoriz_path
+
+    def _set_tickright(self):
+        self._transform = Affine2D().scale(1.0, 1.0)
+        self._snap_threshold = 1.0
+        self._filled = False
+        self._path = self._tickhoriz_path
+
+    _tickvert_path = Path([[-0.0, 0.0], [-0.0, 1.0]])
+
+    def _set_tickup(self):
+        self._transform = Affine2D().scale(1.0, 1.0)
+        self._snap_threshold = 1.0
+        self._filled = False
+        self._path = self._tickvert_path
+
+    def _set_tickdown(self):
+        self._transform = Affine2D().scale(1.0, -1.0)
+        self._snap_threshold = 1.0
+        self._filled = False
+        self._path = self._tickvert_path
+
+    _tri_path = Path([[0.0, 0.0], [0.0, -1.0],
+                      [0.0, 0.0], [0.8, 0.5],
+                      [0.0, 0.0], [-0.8, 0.5]],
+                     [Path.MOVETO, Path.LINETO,
+                      Path.MOVETO, Path.LINETO,
+                      Path.MOVETO, Path.LINETO])
+
+    def _set_tri_down(self):
+        self._transform = Affine2D().scale(0.5)
+        self._snap_threshold = 5.0
+        self._filled = False
+        self._path = self._tri_path
+
+    def _set_tri_up(self):
+        self._set_tri_down()
+        self._transform = self._transform.rotate_deg(180)
+
+    def _set_tri_left(self):
+        self._set_tri_down()
+        self._transform = self._transform.rotate_deg(270)
+
+    def _set_tri_right(self):
+        self._set_tri_down()
+        self._transform = self._transform.rotate_deg(90)
+
+    _caret_path = Path([[-1.0, 1.5], [0.0, 0.0], [1.0, 1.5]])
+
+    def _set_caretdown(self):
+        self._transform = Affine2D().scale(0.5)
+        self._snap_threshold = 3.0
+        self._filled = False
+        self._path = self._caret_path
+        self._joinstyle = self._user_joinstyle or JoinStyle.miter
+
+    def _set_caretup(self):
+        self._set_caretdown()
+        self._transform = self._transform.rotate_deg(180)
+
+    def _set_caretleft(self):
+        self._set_caretdown()
+        self._transform = self._transform.rotate_deg(270)
+
+    def _set_caretright(self):
+        self._set_caretdown()
+        self._transform = self._transform.rotate_deg(90)
+
+    _caret_path_base = Path([[-1.0, 0.0], [0.0, -1.5], [1.0, 0]])
+
+    def _set_caretdownbase(self):
+        self._set_caretdown()
+        self._path = self._caret_path_base
+
+    def _set_caretupbase(self):
+        self._set_caretdownbase()
+        self._transform = self._transform.rotate_deg(180)
+
+    def _set_caretleftbase(self):
+        self._set_caretdownbase()
+        self._transform = self._transform.rotate_deg(270)
+
+    def _set_caretrightbase(self):
+        self._set_caretdownbase()
+        self._transform = self._transform.rotate_deg(90)
+
+    _plus_path = Path([[-1.0, 0.0], [1.0, 0.0],
+                       [0.0, -1.0], [0.0, 1.0]],
+                      [Path.MOVETO, Path.LINETO,
+                       Path.MOVETO, Path.LINETO])
+
+    def _set_plus(self):
+        self._transform = Affine2D().scale(0.5)
+        self._snap_threshold = 1.0
+        self._filled = False
+        self._path = self._plus_path
+
+    _x_path = Path([[-1.0, -1.0], [1.0, 1.0],
+                    [-1.0, 1.0], [1.0, -1.0]],
+                   [Path.MOVETO, Path.LINETO,
+                    Path.MOVETO, Path.LINETO])
+
+    def _set_x(self):
+        self._transform = Affine2D().scale(0.5)
+        self._snap_threshold = 3.0
+        self._filled = False
+        self._path = self._x_path
+
+    _plus_filled_path = Path._create_closed(np.array([
+        (-1, -3), (+1, -3), (+1, -1), (+3, -1), (+3, +1), (+1, +1),
+        (+1, +3), (-1, +3), (-1, +1), (-3, +1), (-3, -1), (-1, -1)]) / 6)
+    _plus_filled_path_t = Path._create_closed(np.array([
+        (+3, 0), (+3, +1), (+1, +1), (+1, +3),
+        (-1, +3), (-1, +1), (-3, +1), (-3, 0)]) / 6)
+
+    def _set_plus_filled(self):
+        self._transform = Affine2D()
+        self._snap_threshold = 5.0
+        self._joinstyle = self._user_joinstyle or JoinStyle.miter
+        if not self._half_fill():
+            self._path = self._plus_filled_path
+        else:
+            # Rotate top half path to support all partitions
+            self._path = self._alt_path = self._plus_filled_path_t
+            fs = self.get_fillstyle()
+            self._transform.rotate_deg(
+                {'top': 0, 'left': 90, 'bottom': 180, 'right': 270}[fs])
+            self._alt_transform = self._transform.frozen().rotate_deg(180)
+
+    _x_filled_path = Path._create_closed(np.array([
+        (-1, -2), (0, -1), (+1, -2), (+2, -1), (+1, 0), (+2, +1),
+        (+1, +2), (0, +1), (-1, +2), (-2, +1), (-1, 0), (-2, -1)]) / 4)
+    _x_filled_path_t = Path._create_closed(np.array([
+        (+1, 0), (+2, +1), (+1, +2), (0, +1),
+        (-1, +2), (-2, +1), (-1, 0)]) / 4)
+
+    def _set_x_filled(self):
+        self._transform = Affine2D()
+        self._snap_threshold = 5.0
+        self._joinstyle = self._user_joinstyle or JoinStyle.miter
+        if not self._half_fill():
+            self._path = self._x_filled_path
+        else:
+            # Rotate top half path to support all partitions
+            self._path = self._alt_path = self._x_filled_path_t
+            fs = self.get_fillstyle()
+            self._transform.rotate_deg(
+                {'top': 0, 'left': 90, 'bottom': 180, 'right': 270}[fs])
+            self._alt_transform = self._transform.frozen().rotate_deg(180)

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

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

infer_4_30_0/lib/python3.10/site-packages/matplotlib/mathtext.py

@@ -0,0 +1,140 @@
+r"""
+A module for parsing a subset of the TeX math syntax and rendering it to a
+Matplotlib backend.
+
+For a tutorial of its usage, see :ref:`mathtext`.  This
+document is primarily concerned with implementation details.
+
+The module uses pyparsing_ to parse the TeX expression.
+
+.. _pyparsing: https://pypi.org/project/pyparsing/
+
+The Bakoma distribution of the TeX Computer Modern fonts, and STIX
+fonts are supported.  There is experimental support for using
+arbitrary fonts, but results may vary without proper tweaking and
+metrics for those fonts.
+"""
+
+import functools
+import logging
+
+import matplotlib as mpl
+from matplotlib import _api, _mathtext
+from matplotlib.ft2font import LoadFlags
+from matplotlib.font_manager import FontProperties
+from ._mathtext import (  # noqa: F401, reexported API
+    RasterParse, VectorParse, get_unicode_index)
+
+_log = logging.getLogger(__name__)
+
+
+get_unicode_index.__module__ = __name__
+
+##############################################################################
+# MAIN
+
+
+class MathTextParser:
+    _parser = None
+    _font_type_mapping = {
+        'cm':          _mathtext.BakomaFonts,
+        'dejavuserif': _mathtext.DejaVuSerifFonts,
+        'dejavusans':  _mathtext.DejaVuSansFonts,
+        'stix':        _mathtext.StixFonts,
+        'stixsans':    _mathtext.StixSansFonts,
+        'custom':      _mathtext.UnicodeFonts,
+    }
+
+    def __init__(self, output):
+        """
+        Create a MathTextParser for the given backend *output*.
+
+        Parameters
+        ----------
+        output : {"path", "agg"}
+            Whether to return a `VectorParse` ("path") or a
+            `RasterParse` ("agg", or its synonym "macosx").
+        """
+        self._output_type = _api.check_getitem(
+            {"path": "vector", "agg": "raster", "macosx": "raster"},
+            output=output.lower())
+
+    def parse(self, s, dpi=72, prop=None, *, antialiased=None):
+        """
+        Parse the given math expression *s* at the given *dpi*.  If *prop* is
+        provided, it is a `.FontProperties` object specifying the "default"
+        font to use in the math expression, used for all non-math text.
+
+        The results are cached, so multiple calls to `parse`
+        with the same expression should be fast.
+
+        Depending on the *output* type, this returns either a `VectorParse` or
+        a `RasterParse`.
+        """
+        # lru_cache can't decorate parse() directly because prop is
+        # mutable, so we key the cache using an internal copy (see
+        # Text._get_text_metrics_with_cache for a similar case); likewise,
+        # we need to check the mutable state of the text.antialiased and
+        # text.hinting rcParams.
+        prop = prop.copy() if prop is not None else None
+        antialiased = mpl._val_or_rc(antialiased, 'text.antialiased')
+        from matplotlib.backends import backend_agg
+        load_glyph_flags = {
+            "vector": LoadFlags.NO_HINTING,
+            "raster": backend_agg.get_hinting_flag(),
+        }[self._output_type]
+        return self._parse_cached(s, dpi, prop, antialiased, load_glyph_flags)
+
+    @functools.lru_cache(50)
+    def _parse_cached(self, s, dpi, prop, antialiased, load_glyph_flags):
+        if prop is None:
+            prop = FontProperties()
+        fontset_class = _api.check_getitem(
+            self._font_type_mapping, fontset=prop.get_math_fontfamily())
+        fontset = fontset_class(prop, load_glyph_flags)
+        fontsize = prop.get_size_in_points()
+
+        if self._parser is None:  # Cache the parser globally.
+            self.__class__._parser = _mathtext.Parser()
+
+        box = self._parser.parse(s, fontset, fontsize, dpi)
+        output = _mathtext.ship(box)
+        if self._output_type == "vector":
+            return output.to_vector()
+        elif self._output_type == "raster":
+            return output.to_raster(antialiased=antialiased)
+
+
+def math_to_image(s, filename_or_obj, prop=None, dpi=None, format=None,
+                  *, color=None):
+    """
+    Given a math expression, renders it in a closely-clipped bounding
+    box to an image file.
+
+    Parameters
+    ----------
+    s : str
+        A math expression.  The math portion must be enclosed in dollar signs.
+    filename_or_obj : str or path-like or file-like
+        Where to write the image data.
+    prop : `.FontProperties`, optional
+        The size and style of the text.
+    dpi : float, optional
+        The output dpi.  If not set, the dpi is determined as for
+        `.Figure.savefig`.
+    format : str, optional
+        The output format, e.g., 'svg', 'pdf', 'ps' or 'png'.  If not set, the
+        format is determined as for `.Figure.savefig`.
+    color : str, optional
+        Foreground color, defaults to :rc:`text.color`.
+    """
+    from matplotlib import figure
+
+    parser = MathTextParser('path')
+    width, height, depth, _, _ = parser.parse(s, dpi=72, prop=prop)
+
+    fig = figure.Figure(figsize=(width / 72.0, height / 72.0))
+    fig.text(0, depth/height, s, fontproperties=prop, color=color)
+    fig.savefig(filename_or_obj, dpi=dpi, format=format)
+
+    return depth

infer_4_30_0/lib/python3.10/site-packages/matplotlib/mathtext.pyi

@@ -0,0 +1,33 @@
+import os
+from typing import Generic, IO, Literal, TypeVar, overload
+
+from matplotlib.font_manager import FontProperties
+from matplotlib.typing import ColorType
+
+# Re-exported API from _mathtext.
+from ._mathtext import (
+    RasterParse as RasterParse,
+    VectorParse as VectorParse,
+    get_unicode_index as get_unicode_index,
+)
+
+_ParseType = TypeVar("_ParseType", RasterParse, VectorParse)
+
+class MathTextParser(Generic[_ParseType]):
+    @overload
+    def __init__(self: MathTextParser[VectorParse], output: Literal["path"]) -> None: ...
+    @overload
+    def __init__(self: MathTextParser[RasterParse], output: Literal["agg", "raster", "macosx"]) -> None: ...
+    def parse(
+        self, s: str, dpi: float = ..., prop: FontProperties | None = ..., *, antialiased: bool | None = ...
+    ) -> _ParseType: ...
+
+def math_to_image(
+    s: str,
+    filename_or_obj: str | os.PathLike | IO,
+    prop: FontProperties | None = ...,
+    dpi: float | None = ...,
+    format: str | None = ...,
+    *,
+    color: ColorType | None = ...
+) -> float: ...

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

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

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

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

infer_4_30_0/lib/python3.10/site-packages/matplotlib/patheffects.py

@@ -0,0 +1,511 @@
+"""
+Defines classes for path effects. The path effects are supported in `.Text`,
+`.Line2D` and `.Patch`.
+
+.. seealso::
+   :ref:`patheffects_guide`
+"""
+
+from matplotlib.backend_bases import RendererBase
+from matplotlib import colors as mcolors
+from matplotlib import patches as mpatches
+from matplotlib import transforms as mtransforms
+from matplotlib.path import Path
+import numpy as np
+
+
+class AbstractPathEffect:
+    """
+    A base class for path effects.
+
+    Subclasses should override the ``draw_path`` method to add effect
+    functionality.
+    """
+
+    def __init__(self, offset=(0., 0.)):
+        """
+        Parameters
+        ----------
+        offset : (float, float), default: (0, 0)
+            The (x, y) offset to apply to the path, measured in points.
+        """
+        self._offset = offset
+
+    def _offset_transform(self, renderer):
+        """Apply the offset to the given transform."""
+        return mtransforms.Affine2D().translate(
+            *map(renderer.points_to_pixels, self._offset))
+
+    def _update_gc(self, gc, new_gc_dict):
+        """
+        Update the given GraphicsContext with the given dict of properties.
+
+        The keys in the dictionary are used to identify the appropriate
+        ``set_`` method on the *gc*.
+        """
+        new_gc_dict = new_gc_dict.copy()
+
+        dashes = new_gc_dict.pop("dashes", None)
+        if dashes:
+            gc.set_dashes(**dashes)
+
+        for k, v in new_gc_dict.items():
+            set_method = getattr(gc, 'set_' + k, None)
+            if not callable(set_method):
+                raise AttributeError(f'Unknown property {k}')
+            set_method(v)
+        return gc
+
+    def draw_path(self, renderer, gc, tpath, affine, rgbFace=None):
+        """
+        Derived should override this method. The arguments are the same
+        as :meth:`matplotlib.backend_bases.RendererBase.draw_path`
+        except the first argument is a renderer.
+        """
+        # Get the real renderer, not a PathEffectRenderer.
+        if isinstance(renderer, PathEffectRenderer):
+            renderer = renderer._renderer
+        return renderer.draw_path(gc, tpath, affine, rgbFace)
+
+
+class PathEffectRenderer(RendererBase):
+    """
+    Implements a Renderer which contains another renderer.
+
+    This proxy then intercepts draw calls, calling the appropriate
+    :class:`AbstractPathEffect` draw method.
+
+    .. note::
+        Not all methods have been overridden on this RendererBase subclass.
+        It may be necessary to add further methods to extend the PathEffects
+        capabilities further.
+    """
+
+    def __init__(self, path_effects, renderer):
+        """
+        Parameters
+        ----------
+        path_effects : iterable of :class:`AbstractPathEffect`
+            The path effects which this renderer represents.
+        renderer : `~matplotlib.backend_bases.RendererBase` subclass
+
+        """
+        self._path_effects = path_effects
+        self._renderer = renderer
+
+    def copy_with_path_effect(self, path_effects):
+        return self.__class__(path_effects, self._renderer)
+
+    def __getattribute__(self, name):
+        if name in ['flipy', 'get_canvas_width_height', 'new_gc',
+                    'points_to_pixels', '_text2path', 'height', 'width']:
+            return getattr(self._renderer, name)
+        else:
+            return object.__getattribute__(self, name)
+
+    def draw_path(self, gc, tpath, affine, rgbFace=None):
+        for path_effect in self._path_effects:
+            path_effect.draw_path(self._renderer, gc, tpath, affine,
+                                  rgbFace)
+
+    def draw_markers(
+            self, gc, marker_path, marker_trans, path, *args, **kwargs):
+        # We do a little shimmy so that all markers are drawn for each path
+        # effect in turn. Essentially, we induce recursion (depth 1) which is
+        # terminated once we have just a single path effect to work with.
+        if len(self._path_effects) == 1:
+            # Call the base path effect function - this uses the unoptimised
+            # approach of calling "draw_path" multiple times.
+            return super().draw_markers(gc, marker_path, marker_trans, path,
+                                        *args, **kwargs)
+
+        for path_effect in self._path_effects:
+            renderer = self.copy_with_path_effect([path_effect])
+            # Recursively call this method, only next time we will only have
+            # one path effect.
+            renderer.draw_markers(gc, marker_path, marker_trans, path,
+                                  *args, **kwargs)
+
+    def draw_path_collection(self, gc, master_transform, paths, *args,
+                             **kwargs):
+        # We do a little shimmy so that all paths are drawn for each path
+        # effect in turn. Essentially, we induce recursion (depth 1) which is
+        # terminated once we have just a single path effect to work with.
+        if len(self._path_effects) == 1:
+            # Call the base path effect function - this uses the unoptimised
+            # approach of calling "draw_path" multiple times.
+            return super().draw_path_collection(gc, master_transform, paths,
+                                                *args, **kwargs)
+
+        for path_effect in self._path_effects:
+            renderer = self.copy_with_path_effect([path_effect])
+            # Recursively call this method, only next time we will only have
+            # one path effect.
+            renderer.draw_path_collection(gc, master_transform, paths,
+                                          *args, **kwargs)
+
+    def open_group(self, s, gid=None):
+        return self._renderer.open_group(s, gid)
+
+    def close_group(self, s):
+        return self._renderer.close_group(s)
+
+
+class Normal(AbstractPathEffect):
+    """
+    The "identity" PathEffect.
+
+    The Normal PathEffect's sole purpose is to draw the original artist with
+    no special path effect.
+    """
+
+
+def _subclass_with_normal(effect_class):
+    """
+    Create a PathEffect class combining *effect_class* and a normal draw.
+    """
+
+    class withEffect(effect_class):
+        def draw_path(self, renderer, gc, tpath, affine, rgbFace):
+            super().draw_path(renderer, gc, tpath, affine, rgbFace)
+            renderer.draw_path(gc, tpath, affine, rgbFace)
+
+    withEffect.__name__ = f"with{effect_class.__name__}"
+    withEffect.__qualname__ = f"with{effect_class.__name__}"
+    withEffect.__doc__ = f"""
+    A shortcut PathEffect for applying `.{effect_class.__name__}` and then
+    drawing the original Artist.
+
+    With this class you can use ::
+
+        artist.set_path_effects([patheffects.with{effect_class.__name__}()])
+
+    as a shortcut for ::
+
+        artist.set_path_effects([patheffects.{effect_class.__name__}(),
+                                 patheffects.Normal()])
+    """
+    # Docstring inheritance doesn't work for locally-defined subclasses.
+    withEffect.draw_path.__doc__ = effect_class.draw_path.__doc__
+    return withEffect
+
+
+class Stroke(AbstractPathEffect):
+    """A line based PathEffect which re-draws a stroke."""
+
+    def __init__(self, offset=(0, 0), **kwargs):
+        """
+        The path will be stroked with its gc updated with the given
+        keyword arguments, i.e., the keyword arguments should be valid
+        gc parameter values.
+        """
+        super().__init__(offset)
+        self._gc = kwargs
+
+    def draw_path(self, renderer, gc, tpath, affine, rgbFace):
+        """Draw the path with updated gc."""
+        gc0 = renderer.new_gc()  # Don't modify gc, but a copy!
+        gc0.copy_properties(gc)
+        gc0 = self._update_gc(gc0, self._gc)
+        renderer.draw_path(
+            gc0, tpath, affine + self._offset_transform(renderer), rgbFace)
+        gc0.restore()
+
+
+withStroke = _subclass_with_normal(effect_class=Stroke)
+
+
+class SimplePatchShadow(AbstractPathEffect):
+    """A simple shadow via a filled patch."""
+
+    def __init__(self, offset=(2, -2),
+                 shadow_rgbFace=None, alpha=None,
+                 rho=0.3, **kwargs):
+        """
+        Parameters
+        ----------
+        offset : (float, float), default: (2, -2)
+            The (x, y) offset of the shadow in points.
+        shadow_rgbFace : :mpltype:`color`
+            The shadow color.
+        alpha : float, default: 0.3
+            The alpha transparency of the created shadow patch.
+        rho : float, default: 0.3
+            A scale factor to apply to the rgbFace color if *shadow_rgbFace*
+            is not specified.
+        **kwargs
+            Extra keywords are stored and passed through to
+            :meth:`AbstractPathEffect._update_gc`.
+
+        """
+        super().__init__(offset)
+
+        if shadow_rgbFace is None:
+            self._shadow_rgbFace = shadow_rgbFace
+        else:
+            self._shadow_rgbFace = mcolors.to_rgba(shadow_rgbFace)
+
+        if alpha is None:
+            alpha = 0.3
+
+        self._alpha = alpha
+        self._rho = rho
+
+        #: The dictionary of keywords to update the graphics collection with.
+        self._gc = kwargs
+
+    def draw_path(self, renderer, gc, tpath, affine, rgbFace):
+        """
+        Overrides the standard draw_path to add the shadow offset and
+        necessary color changes for the shadow.
+        """
+        gc0 = renderer.new_gc()  # Don't modify gc, but a copy!
+        gc0.copy_properties(gc)
+
+        if self._shadow_rgbFace is None:
+            r, g, b = (rgbFace or (1., 1., 1.))[:3]
+            # Scale the colors by a factor to improve the shadow effect.
+            shadow_rgbFace = (r * self._rho, g * self._rho, b * self._rho)
+        else:
+            shadow_rgbFace = self._shadow_rgbFace
+
+        gc0.set_foreground("none")
+        gc0.set_alpha(self._alpha)
+        gc0.set_linewidth(0)
+
+        gc0 = self._update_gc(gc0, self._gc)
+        renderer.draw_path(
+            gc0, tpath, affine + self._offset_transform(renderer),
+            shadow_rgbFace)
+        gc0.restore()
+
+
+withSimplePatchShadow = _subclass_with_normal(effect_class=SimplePatchShadow)
+
+
+class SimpleLineShadow(AbstractPathEffect):
+    """A simple shadow via a line."""
+
+    def __init__(self, offset=(2, -2),
+                 shadow_color='k', alpha=0.3, rho=0.3, **kwargs):
+        """
+        Parameters
+        ----------
+        offset : (float, float), default: (2, -2)
+            The (x, y) offset to apply to the path, in points.
+        shadow_color : :mpltype:`color`, default: 'black'
+            The shadow color.
+            A value of ``None`` takes the original artist's color
+            with a scale factor of *rho*.
+        alpha : float, default: 0.3
+            The alpha transparency of the created shadow patch.
+        rho : float, default: 0.3
+            A scale factor to apply to the rgbFace color if *shadow_color*
+            is ``None``.
+        **kwargs
+            Extra keywords are stored and passed through to
+            :meth:`AbstractPathEffect._update_gc`.
+        """
+        super().__init__(offset)
+        if shadow_color is None:
+            self._shadow_color = shadow_color
+        else:
+            self._shadow_color = mcolors.to_rgba(shadow_color)
+        self._alpha = alpha
+        self._rho = rho
+        #: The dictionary of keywords to update the graphics collection with.
+        self._gc = kwargs
+
+    def draw_path(self, renderer, gc, tpath, affine, rgbFace):
+        """
+        Overrides the standard draw_path to add the shadow offset and
+        necessary color changes for the shadow.
+        """
+        gc0 = renderer.new_gc()  # Don't modify gc, but a copy!
+        gc0.copy_properties(gc)
+
+        if self._shadow_color is None:
+            r, g, b = (gc0.get_foreground() or (1., 1., 1.))[:3]
+            # Scale the colors by a factor to improve the shadow effect.
+            shadow_rgbFace = (r * self._rho, g * self._rho, b * self._rho)
+        else:
+            shadow_rgbFace = self._shadow_color
+
+        gc0.set_foreground(shadow_rgbFace)
+        gc0.set_alpha(self._alpha)
+
+        gc0 = self._update_gc(gc0, self._gc)
+        renderer.draw_path(
+            gc0, tpath, affine + self._offset_transform(renderer))
+        gc0.restore()
+
+
+class PathPatchEffect(AbstractPathEffect):
+    """
+    Draws a `.PathPatch` instance whose Path comes from the original
+    PathEffect artist.
+    """
+
+    def __init__(self, offset=(0, 0), **kwargs):
+        """
+        Parameters
+        ----------
+        offset : (float, float), default: (0, 0)
+            The (x, y) offset to apply to the path, in points.
+        **kwargs
+            All keyword arguments are passed through to the
+            :class:`~matplotlib.patches.PathPatch` constructor. The
+            properties which cannot be overridden are "path", "clip_box"
+            "transform" and "clip_path".
+        """
+        super().__init__(offset=offset)
+        self.patch = mpatches.PathPatch([], **kwargs)
+
+    def draw_path(self, renderer, gc, tpath, affine, rgbFace):
+        self.patch._path = tpath
+        self.patch.set_transform(affine + self._offset_transform(renderer))
+        self.patch.set_clip_box(gc.get_clip_rectangle())
+        clip_path = gc.get_clip_path()
+        if clip_path and self.patch.get_clip_path() is None:
+            self.patch.set_clip_path(*clip_path)
+        self.patch.draw(renderer)
+
+
+class TickedStroke(AbstractPathEffect):
+    """
+    A line-based PathEffect which draws a path with a ticked style.
+
+    This line style is frequently used to represent constraints in
+    optimization.  The ticks may be used to indicate that one side
+    of the line is invalid or to represent a closed boundary of a
+    domain (i.e. a wall or the edge of a pipe).
+
+    The spacing, length, and angle of ticks can be controlled.
+
+    This line style is sometimes referred to as a hatched line.
+
+    See also the :doc:`/gallery/misc/tickedstroke_demo` example.
+    """
+
+    def __init__(self, offset=(0, 0),
+                 spacing=10.0, angle=45.0, length=np.sqrt(2),
+                 **kwargs):
+        """
+        Parameters
+        ----------
+        offset : (float, float), default: (0, 0)
+            The (x, y) offset to apply to the path, in points.
+        spacing : float, default: 10.0
+            The spacing between ticks in points.
+        angle : float, default: 45.0
+            The angle between the path and the tick in degrees.  The angle
+            is measured as if you were an ant walking along the curve, with
+            zero degrees pointing directly ahead, 90 to your left, -90
+            to your right, and 180 behind you. To change side of the ticks,
+            change sign of the angle.
+        length : float, default: 1.414
+            The length of the tick relative to spacing.
+            Recommended length = 1.414 (sqrt(2)) when angle=45, length=1.0
+            when angle=90 and length=2.0 when angle=60.
+        **kwargs
+            Extra keywords are stored and passed through to
+            :meth:`AbstractPathEffect._update_gc`.
+
+        Examples
+        --------
+        See :doc:`/gallery/misc/tickedstroke_demo`.
+        """
+        super().__init__(offset)
+
+        self._spacing = spacing
+        self._angle = angle
+        self._length = length
+        self._gc = kwargs
+
+    def draw_path(self, renderer, gc, tpath, affine, rgbFace):
+        """Draw the path with updated gc."""
+        # Do not modify the input! Use copy instead.
+        gc0 = renderer.new_gc()
+        gc0.copy_properties(gc)
+
+        gc0 = self._update_gc(gc0, self._gc)
+        trans = affine + self._offset_transform(renderer)
+
+        theta = -np.radians(self._angle)
+        trans_matrix = np.array([[np.cos(theta), -np.sin(theta)],
+                                 [np.sin(theta), np.cos(theta)]])
+
+        # Convert spacing parameter to pixels.
+        spacing_px = renderer.points_to_pixels(self._spacing)
+
+        # Transform before evaluation because to_polygons works at resolution
+        # of one -- assuming it is working in pixel space.
+        transpath = affine.transform_path(tpath)
+
+        # Evaluate path to straight line segments that can be used to
+        # construct line ticks.
+        polys = transpath.to_polygons(closed_only=False)
+
+        for p in polys:
+            x = p[:, 0]
+            y = p[:, 1]
+
+            # Can not interpolate points or draw line if only one point in
+            # polyline.
+            if x.size < 2:
+                continue
+
+            # Find distance between points on the line
+            ds = np.hypot(x[1:] - x[:-1], y[1:] - y[:-1])
+
+            # Build parametric coordinate along curve
+            s = np.concatenate(([0.0], np.cumsum(ds)))
+            s_total = s[-1]
+
+            num = int(np.ceil(s_total / spacing_px)) - 1
+            # Pick parameter values for ticks.
+            s_tick = np.linspace(spacing_px/2, s_total - spacing_px/2, num)
+
+            # Find points along the parameterized curve
+            x_tick = np.interp(s_tick, s, x)
+            y_tick = np.interp(s_tick, s, y)
+
+            # Find unit vectors in local direction of curve
+            delta_s = self._spacing * .001
+            u = (np.interp(s_tick + delta_s, s, x) - x_tick) / delta_s
+            v = (np.interp(s_tick + delta_s, s, y) - y_tick) / delta_s
+
+            # Normalize slope into unit slope vector.
+            n = np.hypot(u, v)
+            mask = n == 0
+            n[mask] = 1.0
+
+            uv = np.array([u / n, v / n]).T
+            uv[mask] = np.array([0, 0]).T
+
+            # Rotate and scale unit vector into tick vector
+            dxy = np.dot(uv, trans_matrix) * self._length * spacing_px
+
+            # Build tick endpoints
+            x_end = x_tick + dxy[:, 0]
+            y_end = y_tick + dxy[:, 1]
+
+            # Interleave ticks to form Path vertices
+            xyt = np.empty((2 * num, 2), dtype=x_tick.dtype)
+            xyt[0::2, 0] = x_tick
+            xyt[1::2, 0] = x_end
+            xyt[0::2, 1] = y_tick
+            xyt[1::2, 1] = y_end
+
+            # Build up vector of Path codes
+            codes = np.tile([Path.MOVETO, Path.LINETO], num)
+
+            # Construct and draw resulting path
+            h = Path(xyt, codes)
+            # Transform back to data space during render
+            renderer.draw_path(gc0, h, affine.inverted() + trans, rgbFace)
+
+        gc0.restore()
+
+
+withTickedStroke = _subclass_with_normal(effect_class=TickedStroke)

infer_4_30_0/lib/python3.10/site-packages/matplotlib/quiver.pyi

@@ -0,0 +1,184 @@
+import matplotlib.artist as martist
+import matplotlib.collections as mcollections
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure, SubFigure
+from matplotlib.text import Text
+from matplotlib.transforms import Transform, Bbox
+
+
+import numpy as np
+from numpy.typing import ArrayLike
+from collections.abc import Sequence
+from typing import Any, Literal, overload
+from matplotlib.typing import ColorType
+
+class QuiverKey(martist.Artist):
+    halign: dict[Literal["N", "S", "E", "W"], Literal["left", "center", "right"]]
+    valign: dict[Literal["N", "S", "E", "W"], Literal["top", "center", "bottom"]]
+    pivot: dict[Literal["N", "S", "E", "W"], Literal["middle", "tip", "tail"]]
+    Q: Quiver
+    X: float
+    Y: float
+    U: float
+    angle: float
+    coord: Literal["axes", "figure", "data", "inches"]
+    color: ColorType | None
+    label: str
+    labelpos: Literal["N", "S", "E", "W"]
+    labelcolor: ColorType | None
+    fontproperties: dict[str, Any]
+    kw: dict[str, Any]
+    text: Text
+    zorder: float
+    def __init__(
+        self,
+        Q: Quiver,
+        X: float,
+        Y: float,
+        U: float,
+        label: str,
+        *,
+        angle: float = ...,
+        coordinates: Literal["axes", "figure", "data", "inches"] = ...,
+        color: ColorType | None = ...,
+        labelsep: float = ...,
+        labelpos: Literal["N", "S", "E", "W"] = ...,
+        labelcolor: ColorType | None = ...,
+        fontproperties: dict[str, Any] | None = ...,
+        zorder: float | None = ...,
+        **kwargs
+    ) -> None: ...
+    @property
+    def labelsep(self) -> float: ...
+    def set_figure(self, fig: Figure | SubFigure) -> None: ...
+
+class Quiver(mcollections.PolyCollection):
+    X: ArrayLike
+    Y: ArrayLike
+    XY: ArrayLike
+    U: ArrayLike
+    V: ArrayLike
+    Umask: ArrayLike
+    N: int
+    scale: float | None
+    headwidth: float
+    headlength: float
+    headaxislength: float
+    minshaft: float
+    minlength: float
+    units: Literal["width", "height", "dots", "inches", "x", "y", "xy"]
+    scale_units: Literal["width", "height", "dots", "inches", "x", "y", "xy"] | None
+    angles: Literal["uv", "xy"] | ArrayLike
+    width: float | None
+    pivot: Literal["tail", "middle", "tip"]
+    transform: Transform
+    polykw: dict[str, Any]
+
+    @overload
+    def __init__(
+        self,
+        ax: Axes,
+        U: ArrayLike,
+        V: ArrayLike,
+        C: ArrayLike = ...,
+        *,
+        scale: float | None = ...,
+        headwidth: float = ...,
+        headlength: float = ...,
+        headaxislength: float = ...,
+        minshaft: float = ...,
+        minlength: float = ...,
+        units: Literal["width", "height", "dots", "inches", "x", "y", "xy"] = ...,
+        scale_units: Literal["width", "height", "dots", "inches", "x", "y", "xy"]
+        | None = ...,
+        angles: Literal["uv", "xy"] | ArrayLike = ...,
+        width: float | None = ...,
+        color: ColorType | Sequence[ColorType] = ...,
+        pivot: Literal["tail", "mid", "middle", "tip"] = ...,
+        **kwargs
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        ax: Axes,
+        X: ArrayLike,
+        Y: ArrayLike,
+        U: ArrayLike,
+        V: ArrayLike,
+        C: ArrayLike = ...,
+        *,
+        scale: float | None = ...,
+        headwidth: float = ...,
+        headlength: float = ...,
+        headaxislength: float = ...,
+        minshaft: float = ...,
+        minlength: float = ...,
+        units: Literal["width", "height", "dots", "inches", "x", "y", "xy"] = ...,
+        scale_units: Literal["width", "height", "dots", "inches", "x", "y", "xy"]
+        | None = ...,
+        angles: Literal["uv", "xy"] | ArrayLike = ...,
+        width: float | None = ...,
+        color: ColorType | Sequence[ColorType] = ...,
+        pivot: Literal["tail", "mid", "middle", "tip"] = ...,
+        **kwargs
+    ) -> None: ...
+    def get_datalim(self, transData: Transform) -> Bbox: ...
+    def set_UVC(
+        self, U: ArrayLike, V: ArrayLike, C: ArrayLike | None = ...
+    ) -> None: ...
+
+class Barbs(mcollections.PolyCollection):
+    sizes: dict[str, float]
+    fill_empty: bool
+    barb_increments: dict[str, float]
+    rounding: bool
+    flip: np.ndarray
+    x: ArrayLike
+    y: ArrayLike
+    u: ArrayLike
+    v: ArrayLike
+
+    @overload
+    def __init__(
+        self,
+        ax: Axes,
+        U: ArrayLike,
+        V: ArrayLike,
+        C: ArrayLike = ...,
+        *,
+        pivot: str = ...,
+        length: int = ...,
+        barbcolor: ColorType | Sequence[ColorType] | None = ...,
+        flagcolor: ColorType | Sequence[ColorType] | None = ...,
+        sizes: dict[str, float] | None = ...,
+        fill_empty: bool = ...,
+        barb_increments: dict[str, float] | None = ...,
+        rounding: bool = ...,
+        flip_barb: bool | ArrayLike = ...,
+        **kwargs
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        ax: Axes,
+        X: ArrayLike,
+        Y: ArrayLike,
+        U: ArrayLike,
+        V: ArrayLike,
+        C: ArrayLike = ...,
+        *,
+        pivot: str = ...,
+        length: int = ...,
+        barbcolor: ColorType | Sequence[ColorType] | None = ...,
+        flagcolor: ColorType | Sequence[ColorType] | None = ...,
+        sizes: dict[str, float] | None = ...,
+        fill_empty: bool = ...,
+        barb_increments: dict[str, float] | None = ...,
+        rounding: bool = ...,
+        flip_barb: bool | ArrayLike = ...,
+        **kwargs
+    ) -> None: ...
+    def set_UVC(
+        self, U: ArrayLike, V: ArrayLike, C: ArrayLike | None = ...
+    ) -> None: ...
+    def set_offsets(self, xy: ArrayLike) -> None: ...

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

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

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

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

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

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