Auto-sync: 2026-06-25 22:43:25 (part 6)

.gitattributes

@@ -52,3 +52,20 @@ outputs/audit_venv/lib/python3.11/site-packages/matplotlib/_qhull.cpython-311-x8
 outputs/audit_venv/lib/python3.11/site-packages/matplotlib/_tri.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 outputs/audit_venv/lib/python3.11/site-packages/matplotlib/backends/_backend_agg.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 outputs/audit_venv/lib/python3.11/site-packages/matplotlib/backends/_tkagg.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/ft2font.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSans-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSans-BoldOblique.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSans-Oblique.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSans.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSansMono-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSansMono-BoldOblique.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSansMono-Oblique.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSansMono.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSerif-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSerif-BoldItalic.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSerif-Italic.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSerif.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/STIXGeneral.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/STIXGeneralBol.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/STIXGeneralBolIta.ttf filter=lfs diff=lfs merge=lfs -text
+outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/ttf/STIXGeneralItalic.ttf filter=lfs diff=lfs merge=lfs -text

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/collections.py

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

outputs/audit_venv/lib/python3.11/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: ...

outputs/audit_venv/lib/python3.11/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:
+        a._colorbars.append(cax)  # tell the parent it has a colorbar
+    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>")
+    parent._colorbars.append(cax)  # tell the parent it has a 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

outputs/audit_venv/lib/python3.11/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]]: ...

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/colorizer.py

@@ -0,0 +1,703 @@
+"""
+The Colorizer class which handles the data to color pipeline via a
+normalization and a colormap.
+
+.. admonition:: Provisional status of colorizer
+
+    The ``colorizer`` module and classes in this file are considered
+    provisional and may change at any time without a deprecation period.
+
+.. seealso::
+
+  :doc:`/gallery/color/colormap_reference` for a list of builtin colormaps.
+
+  :ref:`colormap-manipulation` for examples of how to make colormaps.
+
+  :ref:`colormaps` for an in-depth discussion of choosing colormaps.
+
+  :ref:`colormapnorms` for more details about data normalization.
+
+"""
+
+import functools
+
+import numpy as np
+from numpy import ma
+
+from matplotlib import _api, colors, cbook, scale, artist
+import matplotlib as mpl
+
+mpl._docstring.interpd.register(
+    colorizer_doc="""\
+colorizer : `~matplotlib.colorizer.Colorizer` or None, default: None
+    The Colorizer object used to map color to data. If None, a Colorizer
+    object is created from a *norm* and *cmap*.""",
+    )
+
+
+class Colorizer:
+    """
+    Data to color pipeline.
+
+    This pipeline is accessible via `.Colorizer.to_rgba` and executed via
+    the `.Colorizer.norm` and `.Colorizer.cmap` attributes.
+
+    Parameters
+    ----------
+    cmap: colorbar.Colorbar or str or None, default: None
+        The colormap used to color data.
+
+    norm: colors.Normalize or str or None, default: None
+        The normalization used to normalize the data
+    """
+    def __init__(self, cmap=None, norm=None):
+
+        self._cmap = None
+        self._set_cmap(cmap)
+
+        self._id_norm = None
+        self._norm = None
+        self.norm = norm
+
+        self.callbacks = cbook.CallbackRegistry(signals=["changed"])
+        self.colorbar = None
+
+    def _scale_norm(self, norm, vmin, vmax, A):
+        """
+        Helper for initial scaling.
+
+        Used by public functions that create a ScalarMappable and support
+        parameters *vmin*, *vmax* and *norm*. This makes sure that a *norm*
+        will take precedence over *vmin*, *vmax*.
+
+        Note that this method does not set the norm.
+        """
+        if vmin is not None or vmax is not None:
+            self.set_clim(vmin, vmax)
+            if isinstance(norm, colors.Normalize):
+                raise ValueError(
+                    "Passing a Normalize instance simultaneously with "
+                    "vmin/vmax is not supported.  Please pass vmin/vmax "
+                    "directly to the norm when creating it.")
+
+        # always resolve the autoscaling so we have concrete limits
+        # rather than deferring to draw time.
+        self.autoscale_None(A)
+
+    @property
+    def norm(self):
+        return self._norm
+
+    @norm.setter
+    def norm(self, norm):
+        _api.check_isinstance((colors.Normalize, str, None), norm=norm)
+        if norm is None:
+            norm = colors.Normalize()
+        elif isinstance(norm, str):
+            try:
+                scale_cls = scale._scale_mapping[norm]
+            except KeyError:
+                raise ValueError(
+                    "Invalid norm str name; the following values are "
+                    f"supported: {', '.join(scale._scale_mapping)}"
+                ) from None
+            norm = _auto_norm_from_scale(scale_cls)()
+
+        if norm is self.norm:
+            # We aren't updating anything
+            return
+
+        in_init = self.norm is None
+        # Remove the current callback and connect to the new one
+        if not in_init:
+            self.norm.callbacks.disconnect(self._id_norm)
+        self._norm = norm
+        self._id_norm = self.norm.callbacks.connect('changed',
+                                                    self.changed)
+        if not in_init:
+            self.changed()
+
+    def to_rgba(self, x, alpha=None, bytes=False, norm=True):
+        """
+        Return a normalized RGBA array corresponding to *x*.
+
+        In the normal case, *x* is a 1D or 2D sequence of scalars, and
+        the corresponding `~numpy.ndarray` of RGBA values will be returned,
+        based on the norm and colormap set for this Colorizer.
+
+        There is one special case, for handling images that are already
+        RGB or RGBA, such as might have been read from an image file.
+        If *x* is an `~numpy.ndarray` with 3 dimensions,
+        and the last dimension is either 3 or 4, then it will be
+        treated as an RGB or RGBA array, and no mapping will be done.
+        The array can be `~numpy.uint8`, or it can be floats with
+        values in the 0-1 range; otherwise a ValueError will be raised.
+        Any NaNs or masked elements will be set to 0 alpha.
+        If the last dimension is 3, the *alpha* kwarg (defaulting to 1)
+        will be used to fill in the transparency.  If the last dimension
+        is 4, the *alpha* kwarg is ignored; it does not
+        replace the preexisting alpha.  A ValueError will be raised
+        if the third dimension is other than 3 or 4.
+
+        In either case, if *bytes* is *False* (default), the RGBA
+        array will be floats in the 0-1 range; if it is *True*,
+        the returned RGBA array will be `~numpy.uint8` in the 0 to 255 range.
+
+        If norm is False, no normalization of the input data is
+        performed, and it is assumed to be in the range (0-1).
+
+        """
+        # First check for special case, image input:
+        if isinstance(x, np.ndarray) and x.ndim == 3:
+            return self._pass_image_data(x, alpha, bytes, norm)
+
+        # Otherwise run norm -> colormap pipeline
+        x = ma.asarray(x)
+        if norm:
+            x = self.norm(x)
+        rgba = self.cmap(x, alpha=alpha, bytes=bytes)
+        return rgba
+
+    @staticmethod
+    def _pass_image_data(x, alpha=None, bytes=False, norm=True):
+        """
+        Helper function to pass ndarray of shape (...,3) or (..., 4)
+        through `to_rgba()`, see `to_rgba()` for docstring.
+        """
+        if x.shape[2] == 3:
+            if alpha is None:
+                alpha = 1
+            if x.dtype == np.uint8:
+                alpha = np.uint8(alpha * 255)
+            m, n = x.shape[:2]
+            xx = np.empty(shape=(m, n, 4), dtype=x.dtype)
+            xx[:, :, :3] = x
+            xx[:, :, 3] = alpha
+        elif x.shape[2] == 4:
+            xx = x
+        else:
+            raise ValueError("Third dimension must be 3 or 4")
+        if xx.dtype.kind == 'f':
+            # If any of R, G, B, or A is nan, set to 0
+            if np.any(nans := np.isnan(x)):
+                if x.shape[2] == 4:
+                    xx = xx.copy()
+                xx[np.any(nans, axis=2), :] = 0
+
+            if norm and (xx.max() > 1 or xx.min() < 0):
+                raise ValueError("Floating point image RGB values "
+                                 "must be in the 0..1 range.")
+            if bytes:
+                xx = (xx * 255).astype(np.uint8)
+        elif xx.dtype == np.uint8:
+            if not bytes:
+                xx = xx.astype(np.float32) / 255
+        else:
+            raise ValueError("Image RGB array must be uint8 or "
+                             "floating point; found %s" % xx.dtype)
+        # Account for any masked entries in the original array
+        # If any of R, G, B, or A are masked for an entry, we set alpha to 0
+        if np.ma.is_masked(x):
+            xx[np.any(np.ma.getmaskarray(x), axis=2), 3] = 0
+        return xx
+
+    def autoscale(self, A):
+        """
+        Autoscale the scalar limits on the norm instance using the
+        current array
+        """
+        if A is None:
+            raise TypeError('You must first set_array for mappable')
+        # If the norm's limits are updated self.changed() will be called
+        # through the callbacks attached to the norm
+        self.norm.autoscale(A)
+
+    def autoscale_None(self, A):
+        """
+        Autoscale the scalar limits on the norm instance using the
+        current array, changing only limits that are None
+        """
+        if A is None:
+            raise TypeError('You must first set_array for mappable')
+        # If the norm's limits are updated self.changed() will be called
+        # through the callbacks attached to the norm
+        self.norm.autoscale_None(A)
+
+    def _set_cmap(self, cmap):
+        """
+        Set the colormap for luminance data.
+
+        Parameters
+        ----------
+        cmap : `.Colormap` or str or None
+        """
+        # bury import to avoid circular imports
+        from matplotlib import cm
+        in_init = self._cmap is None
+        self._cmap = cm._ensure_cmap(cmap)
+        if not in_init:
+            self.changed()  # Things are not set up properly yet.
+
+    @property
+    def cmap(self):
+        return self._cmap
+
+    @cmap.setter
+    def cmap(self, cmap):
+        self._set_cmap(cmap)
+
+    def set_clim(self, vmin=None, vmax=None):
+        """
+        Set the norm limits for image scaling.
+
+        Parameters
+        ----------
+        vmin, vmax : float
+             The limits.
+
+             The limits may also be passed as a tuple (*vmin*, *vmax*) as a
+             single positional argument.
+
+             .. ACCEPTS: (vmin: float, vmax: float)
+        """
+        # If the norm's limits are updated self.changed() will be called
+        # through the callbacks attached to the norm, this causes an inconsistent
+        # state, to prevent this blocked context manager is used
+        if vmax is None:
+            try:
+                vmin, vmax = vmin
+            except (TypeError, ValueError):
+                pass
+
+        orig_vmin_vmax = self.norm.vmin, self.norm.vmax
+
+        # Blocked context manager prevents callbacks from being triggered
+        # until both vmin and vmax are updated
+        with self.norm.callbacks.blocked(signal='changed'):
+            if vmin is not None:
+                self.norm.vmin = colors._sanitize_extrema(vmin)
+            if vmax is not None:
+                self.norm.vmax = colors._sanitize_extrema(vmax)
+
+        # emit a update signal if the limits are changed
+        if orig_vmin_vmax != (self.norm.vmin, self.norm.vmax):
+            self.norm.callbacks.process('changed')
+
+    def get_clim(self):
+        """
+        Return the values (min, max) that are mapped to the colormap limits.
+        """
+        return self.norm.vmin, self.norm.vmax
+
+    def changed(self):
+        """
+        Call this whenever the mappable is changed to notify all the
+        callbackSM listeners to the 'changed' signal.
+        """
+        self.callbacks.process('changed')
+        self.stale = True
+
+    @property
+    def vmin(self):
+        return self.get_clim()[0]
+
+    @vmin.setter
+    def vmin(self, vmin):
+        self.set_clim(vmin=vmin)
+
+    @property
+    def vmax(self):
+        return self.get_clim()[1]
+
+    @vmax.setter
+    def vmax(self, vmax):
+        self.set_clim(vmax=vmax)
+
+    @property
+    def clip(self):
+        return self.norm.clip
+
+    @clip.setter
+    def clip(self, clip):
+        self.norm.clip = clip
+
+
+class _ColorizerInterface:
+    """
+    Base class that contains the interface to `Colorizer` objects from
+    a `ColorizingArtist` or `.cm.ScalarMappable`.
+
+    Note: This class only contain functions that interface the .colorizer
+    attribute. Other functions that as shared between `.ColorizingArtist`
+    and `.cm.ScalarMappable` are not included.
+    """
+    def _scale_norm(self, norm, vmin, vmax):
+        self._colorizer._scale_norm(norm, vmin, vmax, self._A)
+
+    def to_rgba(self, x, alpha=None, bytes=False, norm=True):
+        """
+        Return a normalized RGBA array corresponding to *x*.
+
+        In the normal case, *x* is a 1D or 2D sequence of scalars, and
+        the corresponding `~numpy.ndarray` of RGBA values will be returned,
+        based on the norm and colormap set for this Colorizer.
+
+        There is one special case, for handling images that are already
+        RGB or RGBA, such as might have been read from an image file.
+        If *x* is an `~numpy.ndarray` with 3 dimensions,
+        and the last dimension is either 3 or 4, then it will be
+        treated as an RGB or RGBA array, and no mapping will be done.
+        The array can be `~numpy.uint8`, or it can be floats with
+        values in the 0-1 range; otherwise a ValueError will be raised.
+        Any NaNs or masked elements will be set to 0 alpha.
+        If the last dimension is 3, the *alpha* kwarg (defaulting to 1)
+        will be used to fill in the transparency.  If the last dimension
+        is 4, the *alpha* kwarg is ignored; it does not
+        replace the preexisting alpha.  A ValueError will be raised
+        if the third dimension is other than 3 or 4.
+
+        In either case, if *bytes* is *False* (default), the RGBA
+        array will be floats in the 0-1 range; if it is *True*,
+        the returned RGBA array will be `~numpy.uint8` in the 0 to 255 range.
+
+        If norm is False, no normalization of the input data is
+        performed, and it is assumed to be in the range (0-1).
+
+        """
+        return self._colorizer.to_rgba(x, alpha=alpha, bytes=bytes, norm=norm)
+
+    def get_clim(self):
+        """
+        Return the values (min, max) that are mapped to the colormap limits.
+        """
+        return self._colorizer.get_clim()
+
+    def set_clim(self, vmin=None, vmax=None):
+        """
+        Set the norm limits for image scaling.
+
+        Parameters
+        ----------
+        vmin, vmax : float
+             The limits.
+
+             For scalar data, the limits may also be passed as a
+             tuple (*vmin*, *vmax*) as a single positional argument.
+
+             .. ACCEPTS: (vmin: float, vmax: float)
+        """
+        # If the norm's limits are updated self.changed() will be called
+        # through the callbacks attached to the norm
+        self._colorizer.set_clim(vmin, vmax)
+
+    def get_alpha(self):
+        try:
+            return super().get_alpha()
+        except AttributeError:
+            return 1
+
+    @property
+    def cmap(self):
+        return self._colorizer.cmap
+
+    @cmap.setter
+    def cmap(self, cmap):
+        self._colorizer.cmap = cmap
+
+    def get_cmap(self):
+        """Return the `.Colormap` instance."""
+        return self._colorizer.cmap
+
+    def set_cmap(self, cmap):
+        """
+        Set the colormap for luminance data.
+
+        Parameters
+        ----------
+        cmap : `.Colormap` or str or None
+        """
+        self.cmap = cmap
+
+    @property
+    def norm(self):
+        return self._colorizer.norm
+
+    @norm.setter
+    def norm(self, norm):
+        self._colorizer.norm = norm
+
+    def set_norm(self, norm):
+        """
+        Set the normalization instance.
+
+        Parameters
+        ----------
+        norm : `.Normalize` or str or None
+
+        Notes
+        -----
+        If there are any colorbars using the mappable for this norm, setting
+        the norm of the mappable will reset the norm, locator, and formatters
+        on the colorbar to default.
+        """
+        self.norm = norm
+
+    def autoscale(self):
+        """
+        Autoscale the scalar limits on the norm instance using the
+        current array
+        """
+        self._colorizer.autoscale(self._A)
+
+    def autoscale_None(self):
+        """
+        Autoscale the scalar limits on the norm instance using the
+        current array, changing only limits that are None
+        """
+        self._colorizer.autoscale_None(self._A)
+
+    @property
+    def colorbar(self):
+        """
+        The last colorbar associated with this object. May be None
+        """
+        return self._colorizer.colorbar
+
+    @colorbar.setter
+    def colorbar(self, colorbar):
+        self._colorizer.colorbar = colorbar
+
+    def _format_cursor_data_override(self, data):
+        # This function overwrites Artist.format_cursor_data(). We cannot
+        # implement cm.ScalarMappable.format_cursor_data() directly, because
+        # most cm.ScalarMappable subclasses inherit from Artist first and from
+        # cm.ScalarMappable second, so Artist.format_cursor_data would always
+        # have precedence over cm.ScalarMappable.format_cursor_data.
+
+        # Note if cm.ScalarMappable is depreciated, this functionality should be
+        # implemented as format_cursor_data() on ColorizingArtist.
+        n = self.cmap.N
+        if np.ma.getmask(data):
+            return "[]"
+        normed = self.norm(data)
+        if np.isfinite(normed):
+            if isinstance(self.norm, colors.BoundaryNorm):
+                # not an invertible normalization mapping
+                cur_idx = np.argmin(np.abs(self.norm.boundaries - data))
+                neigh_idx = max(0, cur_idx - 1)
+                # use max diff to prevent delta == 0
+                delta = np.diff(
+                    self.norm.boundaries[neigh_idx:cur_idx + 2]
+                ).max()
+            elif self.norm.vmin == self.norm.vmax:
+                # singular norms, use delta of 10% of only value
+                delta = np.abs(self.norm.vmin * .1)
+            else:
+                # Midpoints of neighboring color intervals.
+                neighbors = self.norm.inverse(
+                    (int(normed * n) + np.array([0, 1])) / n)
+                delta = abs(neighbors - data).max()
+            g_sig_digits = cbook._g_sig_digits(data, delta)
+        else:
+            g_sig_digits = 3  # Consistent with default below.
+        return f"[{data:-#.{g_sig_digits}g}]"
+
+
+class _ScalarMappable(_ColorizerInterface):
+    """
+    A mixin class to map one or multiple sets of scalar data to RGBA.
+
+    The ScalarMappable applies data normalization before returning RGBA colors from
+    the given `~matplotlib.colors.Colormap`.
+    """
+
+    # _ScalarMappable exists for compatibility with
+    # code written before the introduction of the Colorizer
+    # and ColorizingArtist classes.
+
+    # _ScalarMappable can be depreciated so that ColorizingArtist
+    # inherits directly from _ColorizerInterface.
+    # in this case, the following changes should occur:
+    # __init__() has its functionality moved to ColorizingArtist.
+    # set_array(), get_array(), _get_colorizer() and
+    # _check_exclusionary_keywords() are moved to ColorizingArtist.
+    # changed() can be removed so long as colorbar.Colorbar
+    # is changed to connect to the colorizer instead of the
+    # ScalarMappable/ColorizingArtist,
+    # otherwise changed() can be moved to ColorizingArtist.
+    def __init__(self, norm=None, cmap=None, *, colorizer=None, **kwargs):
+        """
+        Parameters
+        ----------
+        norm : `.Normalize` (or subclass thereof) or str or None
+            The normalizing object which scales data, typically into the
+            interval ``[0, 1]``.
+            If a `str`, a `.Normalize` subclass is dynamically generated based
+            on the scale with the corresponding name.
+            If *None*, *norm* defaults to a *colors.Normalize* object which
+            initializes its scaling based on the first data processed.
+        cmap : str or `~matplotlib.colors.Colormap`
+            The colormap used to map normalized data values to RGBA colors.
+        """
+        super().__init__(**kwargs)
+        self._A = None
+        self._colorizer = self._get_colorizer(colorizer=colorizer, norm=norm, cmap=cmap)
+
+        self.colorbar = None
+        self._id_colorizer = self._colorizer.callbacks.connect('changed', self.changed)
+        self.callbacks = cbook.CallbackRegistry(signals=["changed"])
+
+    def set_array(self, A):
+        """
+        Set the value array from array-like *A*.
+
+        Parameters
+        ----------
+        A : array-like or None
+            The values that are mapped to colors.
+
+            The base class `.ScalarMappable` does not make any assumptions on
+            the dimensionality and shape of the value array *A*.
+        """
+        if A is None:
+            self._A = None
+            return
+
+        A = cbook.safe_masked_invalid(A, copy=True)
+        if not np.can_cast(A.dtype, float, "same_kind"):
+            raise TypeError(f"Image data of dtype {A.dtype} cannot be "
+                            "converted to float")
+
+        self._A = A
+        if not self.norm.scaled():
+            self._colorizer.autoscale_None(A)
+
+    def get_array(self):
+        """
+        Return the array of values, that are mapped to colors.
+
+        The base class `.ScalarMappable` does not make any assumptions on
+        the dimensionality and shape of the array.
+        """
+        return self._A
+
+    def changed(self):
+        """
+        Call this whenever the mappable is changed to notify all the
+        callbackSM listeners to the 'changed' signal.
+        """
+        self.callbacks.process('changed', self)
+        self.stale = True
+
+    @staticmethod
+    def _check_exclusionary_keywords(colorizer, **kwargs):
+        """
+        Raises a ValueError if any kwarg is not None while colorizer is not None
+        """
+        if colorizer is not None:
+            if any([val is not None for val in kwargs.values()]):
+                raise ValueError("The `colorizer` keyword cannot be used simultaneously"
+                                 " with any of the following keywords: "
+                                 + ", ".join(f'`{key}`' for key in kwargs.keys()))
+
+    @staticmethod
+    def _get_colorizer(cmap, norm, colorizer):
+        if isinstance(colorizer, Colorizer):
+            _ScalarMappable._check_exclusionary_keywords(
+                Colorizer, cmap=cmap, norm=norm
+            )
+            return colorizer
+        return Colorizer(cmap, norm)
+
+# The docstrings here must be generic enough to apply to all relevant methods.
+mpl._docstring.interpd.register(
+    cmap_doc="""\
+cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
+    The Colormap instance or registered colormap name used to map scalar data
+    to colors.""",
+    norm_doc="""\
+norm : str or `~matplotlib.colors.Normalize`, optional
+    The normalization method used to scale scalar data to the [0, 1] range
+    before mapping to colors using *cmap*. By default, a linear scaling is
+    used, mapping the lowest value to 0 and the highest to 1.
+
+    If given, this can be one of the following:
+
+    - An instance of `.Normalize` or one of its subclasses
+      (see :ref:`colormapnorms`).
+    - A scale name, i.e. one of "linear", "log", "symlog", "logit", etc.  For a
+      list of available scales, call `matplotlib.scale.get_scale_names()`.
+      In that case, a suitable `.Normalize` subclass is dynamically generated
+      and instantiated.""",
+    vmin_vmax_doc="""\
+vmin, vmax : float, optional
+    When using scalar data and no explicit *norm*, *vmin* and *vmax* define
+    the data range that the colormap covers. By default, the colormap covers
+    the complete value range of the supplied data. It is an error to use
+    *vmin*/*vmax* when a *norm* instance is given (but using a `str` *norm*
+    name together with *vmin*/*vmax* is acceptable).""",
+)
+
+
+class ColorizingArtist(_ScalarMappable, artist.Artist):
+    """
+    Base class for artists that make map data to color using a `.colorizer.Colorizer`.
+
+    The `.colorizer.Colorizer` applies data normalization before
+    returning RGBA colors from a `~matplotlib.colors.Colormap`.
+
+    """
+    def __init__(self, colorizer, **kwargs):
+        """
+        Parameters
+        ----------
+        colorizer : `.colorizer.Colorizer`
+        """
+        _api.check_isinstance(Colorizer, colorizer=colorizer)
+        super().__init__(colorizer=colorizer, **kwargs)
+
+    @property
+    def colorizer(self):
+        return self._colorizer
+
+    @colorizer.setter
+    def colorizer(self, cl):
+        _api.check_isinstance(Colorizer, colorizer=cl)
+        self._colorizer.callbacks.disconnect(self._id_colorizer)
+        self._colorizer = cl
+        self._id_colorizer = cl.callbacks.connect('changed', self.changed)
+
+    def _set_colorizer_check_keywords(self, colorizer, **kwargs):
+        """
+        Raises a ValueError if any kwarg is not None while colorizer is not None.
+        """
+        self._check_exclusionary_keywords(colorizer, **kwargs)
+        self.colorizer = colorizer
+
+
+def _auto_norm_from_scale(scale_cls):
+    """
+    Automatically generate a norm class from *scale_cls*.
+
+    This differs from `.colors.make_norm_from_scale` in the following points:
+
+    - This function is not a class decorator, but directly returns a norm class
+      (as if decorating `.Normalize`).
+    - The scale is automatically constructed with ``nonpositive="mask"``, if it
+      supports such a parameter, to work around the difference in defaults
+      between standard scales (which use "clip") and norms (which use "mask").
+
+    Note that ``make_norm_from_scale`` caches the generated norm classes
+    (not the instances) and reuses them for later calls.  For example,
+    ``type(_auto_norm_from_scale("log")) == LogNorm``.
+    """
+    # Actually try to construct an instance, to verify whether
+    # ``nonpositive="mask"`` is supported.
+    try:
+        norm = colors.make_norm_from_scale(
+            functools.partial(scale_cls, nonpositive="mask"))(
+            colors.Normalize)()
+    except TypeError:
+        norm = colors.make_norm_from_scale(scale_cls)(
+            colors.Normalize)()
+    return type(norm)

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/colorizer.pyi

@@ -0,0 +1,102 @@
+from matplotlib import cbook, colorbar, colors, artist
+
+from typing import overload
+import numpy as np
+from numpy.typing import ArrayLike
+
+
+class Colorizer:
+    colorbar: colorbar.Colorbar | None
+    callbacks: cbook.CallbackRegistry
+    def __init__(
+        self,
+        cmap: str | colors.Colormap | None = ...,
+        norm: str | colors.Normalize | None = ...,
+    ) -> None: ...
+    @property
+    def norm(self) -> colors.Normalize: ...
+    @norm.setter
+    def norm(self, norm: colors.Normalize | str | None) -> None: ...
+    def to_rgba(
+        self,
+        x: np.ndarray,
+        alpha: float | ArrayLike | None = ...,
+        bytes: bool = ...,
+        norm: bool = ...,
+    ) -> np.ndarray: ...
+    def autoscale(self, A: ArrayLike) -> None: ...
+    def autoscale_None(self, A: ArrayLike) -> None: ...
+    @property
+    def cmap(self) -> colors.Colormap: ...
+    @cmap.setter
+    def cmap(self, cmap: colors.Colormap | str | None) -> None: ...
+    def get_clim(self) -> tuple[float, float]: ...
+    def set_clim(self, vmin: float | tuple[float, float] | None = ..., vmax: float | None = ...) -> None: ...
+    def changed(self) -> 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: ...
+
+
+class _ColorizerInterface:
+    cmap: colors.Colormap
+    colorbar: colorbar.Colorbar | None
+    callbacks: cbook.CallbackRegistry
+    def to_rgba(
+        self,
+        x: np.ndarray,
+        alpha: float | ArrayLike | None = ...,
+        bytes: bool = ...,
+        norm: bool = ...,
+    ) -> np.ndarray: ...
+    def get_clim(self) -> tuple[float, float]: ...
+    def set_clim(self, vmin: float | tuple[float, float] | None = ..., vmax: float | None = ...) -> None: ...
+    def get_alpha(self) -> float | None: ...
+    def get_cmap(self) -> colors.Colormap: ...
+    def set_cmap(self, cmap: str | colors.Colormap) -> None: ...
+    @property
+    def norm(self) -> colors.Normalize: ...
+    @norm.setter
+    def norm(self, norm: colors.Normalize | str | None) -> None: ...
+    def set_norm(self, norm: colors.Normalize | str | None) -> None: ...
+    def autoscale(self) -> None: ...
+    def autoscale_None(self) -> None: ...
+
+
+class _ScalarMappable(_ColorizerInterface):
+    def __init__(
+        self,
+        norm: colors.Normalize | None = ...,
+        cmap: str | colors.Colormap | None = ...,
+        *,
+        colorizer: Colorizer | None = ...,
+        **kwargs
+    ) -> None: ...
+    def set_array(self, A: ArrayLike | None) -> None: ...
+    def get_array(self) -> np.ndarray | None: ...
+    def changed(self) -> None: ...
+
+
+class ColorizingArtist(_ScalarMappable, artist.Artist):
+    callbacks: cbook.CallbackRegistry
+    def __init__(
+        self,
+        colorizer: Colorizer,
+        **kwargs
+    ) -> None: ...
+    def set_array(self, A: ArrayLike | None) -> None: ...
+    def get_array(self) -> np.ndarray | None: ...
+    def changed(self) -> None: ...
+    @property
+    def colorizer(self) -> Colorizer: ...
+    @colorizer.setter
+    def colorizer(self, cl: Colorizer) -> None: ...

outputs/audit_venv/lib/python3.11/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]: ...

outputs/audit_venv/lib/python3.11/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)

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/container.pyi

@@ -0,0 +1,56 @@
+from matplotlib.artist import Artist
+from matplotlib.lines import Line2D
+from matplotlib.collections import LineCollection
+from matplotlib.patches import Rectangle
+
+from collections.abc import Callable
+from typing import Any, Literal
+from numpy.typing import ArrayLike
+
+class Container(tuple):
+    def __new__(cls, *args, **kwargs): ...
+    def __init__(self, kl, label: Any | None = ...) -> None: ...
+    def remove(self) -> None: ...
+    def get_children(self) -> list[Artist]: ...
+    def get_label(self) -> str | None: ...
+    def set_label(self, s: Any) -> None: ...
+    def add_callback(self, func: Callable[[Artist], Any]) -> int: ...
+    def remove_callback(self, oid: int) -> None: ...
+    def pchanged(self) -> None: ...
+
+class BarContainer(Container):
+    patches: list[Rectangle]
+    errorbar: None | ErrorbarContainer
+    datavalues: None | ArrayLike
+    orientation: None | Literal["vertical", "horizontal"]
+    def __init__(
+        self,
+        patches: list[Rectangle],
+        errorbar: ErrorbarContainer | None = ...,
+        *,
+        datavalues: ArrayLike | None = ...,
+        orientation: Literal["vertical", "horizontal"] | None = ...,
+        **kwargs
+    ) -> None: ...
+
+class ErrorbarContainer(Container):
+    lines: tuple[Line2D, tuple[Line2D, ...], tuple[LineCollection, ...]]
+    has_xerr: bool
+    has_yerr: bool
+    def __init__(
+        self,
+        lines: tuple[Line2D, tuple[Line2D, ...], tuple[LineCollection, ...]],
+        has_xerr: bool = ...,
+        has_yerr: bool = ...,
+        **kwargs
+    ) -> None: ...
+
+class StemContainer(Container):
+    markerline: Line2D
+    stemlines: LineCollection
+    baseline: Line2D
+    def __init__(
+        self,
+        markerline_stemlines_baseline: tuple[Line2D, LineCollection, Line2D],
+        **kwargs
+    ) -> None: ...

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/contour.py

@@ -0,0 +1,1702 @@
+"""
+Classes to support contour plotting and labelling for the Axes class.
+"""
+
+from contextlib import ExitStack
+import functools
+import math
+from numbers import Integral
+
+import numpy as np
+from numpy import ma
+
+import matplotlib as mpl
+from matplotlib import _api, _docstring
+from matplotlib.backend_bases import MouseButton
+from matplotlib.lines import Line2D
+from matplotlib.path import Path
+from matplotlib.text import Text
+import matplotlib.ticker as ticker
+import matplotlib.cm as cm
+import matplotlib.colors as mcolors
+import matplotlib.collections as mcoll
+import matplotlib.font_manager as font_manager
+import matplotlib.cbook as cbook
+import matplotlib.patches as mpatches
+import matplotlib.transforms as mtransforms
+
+
+def _contour_labeler_event_handler(cs, inline, inline_spacing, event):
+    canvas = cs.axes.get_figure(root=True).canvas
+    is_button = event.name == "button_press_event"
+    is_key = event.name == "key_press_event"
+    # Quit (even if not in infinite mode; this is consistent with
+    # MATLAB and sometimes quite useful, but will require the user to
+    # test how many points were actually returned before using data).
+    if (is_button and event.button == MouseButton.MIDDLE
+            or is_key and event.key in ["escape", "enter"]):
+        canvas.stop_event_loop()
+    # Pop last click.
+    elif (is_button and event.button == MouseButton.RIGHT
+          or is_key and event.key in ["backspace", "delete"]):
+        # Unfortunately, if one is doing inline labels, then there is currently
+        # no way to fix the broken contour - once humpty-dumpty is broken, he
+        # can't be put back together.  In inline mode, this does nothing.
+        if not inline:
+            cs.pop_label()
+            canvas.draw()
+    # Add new click.
+    elif (is_button and event.button == MouseButton.LEFT
+          # On macOS/gtk, some keys return None.
+          or is_key and event.key is not None):
+        if cs.axes.contains(event)[0]:
+            cs.add_label_near(event.x, event.y, transform=False,
+                              inline=inline, inline_spacing=inline_spacing)
+            canvas.draw()
+
+
+class ContourLabeler:
+    """Mixin to provide labelling capability to `.ContourSet`."""
+
+    def clabel(self, levels=None, *,
+               fontsize=None, inline=True, inline_spacing=5, fmt=None,
+               colors=None, use_clabeltext=False, manual=False,
+               rightside_up=True, zorder=None):
+        """
+        Label a contour plot.
+
+        Adds labels to line contours in this `.ContourSet` (which inherits from
+        this mixin class).
+
+        Parameters
+        ----------
+        levels : array-like, optional
+            A list of level values, that should be labeled. The list must be
+            a subset of ``cs.levels``. If not given, all levels are labeled.
+
+        fontsize : str or float, default: :rc:`font.size`
+            Size in points or relative size e.g., 'smaller', 'x-large'.
+            See `.Text.set_size` for accepted string values.
+
+        colors : :mpltype:`color` or colors or None, default: None
+            The label colors:
+
+            - If *None*, the color of each label matches the color of
+              the corresponding contour.
+
+            - If one string color, e.g., *colors* = 'r' or *colors* =
+              'red', all labels will be plotted in this color.
+
+            - If a tuple of colors (string, float, RGB, etc), different labels
+              will be plotted in different colors in the order specified.
+
+        inline : bool, default: True
+            If ``True`` the underlying contour is removed where the label is
+            placed.
+
+        inline_spacing : float, default: 5
+            Space in pixels to leave on each side of label when placing inline.
+
+            This spacing will be exact for labels at locations where the
+            contour is straight, less so for labels on curved contours.
+
+        fmt : `.Formatter` or str or callable or dict, optional
+            How the levels are formatted:
+
+            - If a `.Formatter`, it is used to format all levels at once, using
+              its `.Formatter.format_ticks` method.
+            - If a str, it is interpreted as a %-style format string.
+            - If a callable, it is called with one level at a time and should
+              return the corresponding label.
+            - If a dict, it should directly map levels to labels.
+
+            The default is to use a standard `.ScalarFormatter`.
+
+        manual : bool or iterable, default: False
+            If ``True``, contour labels will be placed manually using
+            mouse clicks. Click the first button near a contour to
+            add a label, click the second button (or potentially both
+            mouse buttons at once) to finish adding labels. The third
+            button can be used to remove the last label added, but
+            only if labels are not inline. Alternatively, the keyboard
+            can be used to select label locations (enter to end label
+            placement, delete or backspace act like the third mouse button,
+            and any other key will select a label location).
+
+            *manual* can also be an iterable object of (x, y) tuples.
+            Contour labels will be created as if mouse is clicked at each
+            (x, y) position.
+
+        rightside_up : bool, default: True
+            If ``True``, label rotations will always be plus
+            or minus 90 degrees from level.
+
+        use_clabeltext : bool, default: False
+            If ``True``, use `.Text.set_transform_rotates_text` to ensure that
+            label rotation is updated whenever the Axes aspect changes.
+
+        zorder : float or None, default: ``(2 + contour.get_zorder())``
+            zorder of the contour labels.
+
+        Returns
+        -------
+        labels
+            A list of `.Text` instances for the labels.
+        """
+
+        # Based on the input arguments, clabel() adds a list of "label
+        # specific" attributes to the ContourSet object.  These attributes are
+        # all of the form label* and names should be fairly self explanatory.
+        #
+        # Once these attributes are set, clabel passes control to the labels()
+        # method (for automatic label placement) or blocking_input_loop and
+        # _contour_labeler_event_handler (for manual label placement).
+
+        if fmt is None:
+            fmt = ticker.ScalarFormatter(useOffset=False)
+            fmt.create_dummy_axis()
+        self.labelFmt = fmt
+        self._use_clabeltext = use_clabeltext
+        self.labelManual = manual
+        self.rightside_up = rightside_up
+        self._clabel_zorder = 2 + self.get_zorder() if zorder is None else zorder
+
+        if levels is None:
+            levels = self.levels
+            indices = list(range(len(self.cvalues)))
+        else:
+            levlabs = list(levels)
+            indices, levels = [], []
+            for i, lev in enumerate(self.levels):
+                if lev in levlabs:
+                    indices.append(i)
+                    levels.append(lev)
+            if len(levels) < len(levlabs):
+                raise ValueError(f"Specified levels {levlabs} don't match "
+                                 f"available levels {self.levels}")
+        self.labelLevelList = levels
+        self.labelIndiceList = indices
+
+        self._label_font_props = font_manager.FontProperties(size=fontsize)
+
+        if colors is None:
+            self.labelMappable = self
+            self.labelCValueList = np.take(self.cvalues, self.labelIndiceList)
+        else:
+            cmap = mcolors.ListedColormap(colors, N=len(self.labelLevelList))
+            self.labelCValueList = list(range(len(self.labelLevelList)))
+            self.labelMappable = cm.ScalarMappable(cmap=cmap,
+                                                   norm=mcolors.NoNorm())
+
+        self.labelXYs = []
+
+        if np.iterable(manual):
+            for x, y in manual:
+                self.add_label_near(x, y, inline, inline_spacing)
+        elif manual:
+            print('Select label locations manually using first mouse button.')
+            print('End manual selection with second mouse button.')
+            if not inline:
+                print('Remove last label by clicking third mouse button.')
+            mpl._blocking_input.blocking_input_loop(
+                self.axes.get_figure(root=True),
+                ["button_press_event", "key_press_event"],
+                timeout=-1, handler=functools.partial(
+                    _contour_labeler_event_handler,
+                    self, inline, inline_spacing))
+        else:
+            self.labels(inline, inline_spacing)
+
+        return cbook.silent_list('text.Text', self.labelTexts)
+
+    def print_label(self, linecontour, labelwidth):
+        """Return whether a contour is long enough to hold a label."""
+        return (len(linecontour) > 10 * labelwidth
+                or (len(linecontour)
+                    and (np.ptp(linecontour, axis=0) > 1.2 * labelwidth).any()))
+
+    def too_close(self, x, y, lw):
+        """Return whether a label is already near this location."""
+        thresh = (1.2 * lw) ** 2
+        return any((x - loc[0]) ** 2 + (y - loc[1]) ** 2 < thresh
+                   for loc in self.labelXYs)
+
+    def _get_nth_label_width(self, nth):
+        """Return the width of the *nth* label, in pixels."""
+        fig = self.axes.get_figure(root=False)
+        renderer = fig.get_figure(root=True)._get_renderer()
+        return (Text(0, 0,
+                     self.get_text(self.labelLevelList[nth], self.labelFmt),
+                     figure=fig, fontproperties=self._label_font_props)
+                .get_window_extent(renderer).width)
+
+    def get_text(self, lev, fmt):
+        """Get the text of the label."""
+        if isinstance(lev, str):
+            return lev
+        elif isinstance(fmt, dict):
+            return fmt.get(lev, '%1.3f')
+        elif callable(getattr(fmt, "format_ticks", None)):
+            return fmt.format_ticks([*self.labelLevelList, lev])[-1]
+        elif callable(fmt):
+            return fmt(lev)
+        else:
+            return fmt % lev
+
+    def locate_label(self, linecontour, labelwidth):
+        """
+        Find good place to draw a label (relatively flat part of the contour).
+        """
+        ctr_size = len(linecontour)
+        n_blocks = int(np.ceil(ctr_size / labelwidth)) if labelwidth > 1 else 1
+        block_size = ctr_size if n_blocks == 1 else int(labelwidth)
+        # Split contour into blocks of length ``block_size``, filling the last
+        # block by cycling the contour start (per `np.resize` semantics).  (Due
+        # to cycling, the index returned is taken modulo ctr_size.)
+        xx = np.resize(linecontour[:, 0], (n_blocks, block_size))
+        yy = np.resize(linecontour[:, 1], (n_blocks, block_size))
+        yfirst = yy[:, :1]
+        ylast = yy[:, -1:]
+        xfirst = xx[:, :1]
+        xlast = xx[:, -1:]
+        s = (yfirst - yy) * (xlast - xfirst) - (xfirst - xx) * (ylast - yfirst)
+        l = np.hypot(xlast - xfirst, ylast - yfirst)
+        # Ignore warning that divide by zero throws, as this is a valid option
+        with np.errstate(divide='ignore', invalid='ignore'):
+            distances = (abs(s) / l).sum(axis=-1)
+        # Labels are drawn in the middle of the block (``hbsize``) where the
+        # contour is the closest (per ``distances``) to a straight line, but
+        # not `too_close()` to a preexisting label.
+        hbsize = block_size // 2
+        adist = np.argsort(distances)
+        # If all candidates are `too_close()`, go back to the straightest part
+        # (``adist[0]``).
+        for idx in np.append(adist, adist[0]):
+            x, y = xx[idx, hbsize], yy[idx, hbsize]
+            if not self.too_close(x, y, labelwidth):
+                break
+        return x, y, (idx * block_size + hbsize) % ctr_size
+
+    def _split_path_and_get_label_rotation(self, path, idx, screen_pos, lw, spacing=5):
+        """
+        Prepare for insertion of a label at index *idx* of *path*.
+
+        Parameters
+        ----------
+        path : Path
+            The path where the label will be inserted, in data space.
+        idx : int
+            The vertex index after which the label will be inserted.
+        screen_pos : (float, float)
+            The position where the label will be inserted, in screen space.
+        lw : float
+            The label width, in screen space.
+        spacing : float
+            Extra spacing around the label, in screen space.
+
+        Returns
+        -------
+        path : Path
+            The path, broken so that the label can be drawn over it.
+        angle : float
+            The rotation of the label.
+
+        Notes
+        -----
+        Both tasks are done together to avoid calculating path lengths multiple times,
+        which is relatively costly.
+
+        The method used here involves computing the path length along the contour in
+        pixel coordinates and then looking (label width / 2) away from central point to
+        determine rotation and then to break contour if desired.  The extra spacing is
+        taken into account when breaking the path, but not when computing the angle.
+        """
+        xys = path.vertices
+        codes = path.codes
+
+        # Insert a vertex at idx/pos (converting back to data space), if there isn't yet
+        # a vertex there.  With infinite precision one could also always insert the
+        # extra vertex (it will get masked out by the label below anyways), but floating
+        # point inaccuracies (the point can have undergone a data->screen->data
+        # transform loop) can slightly shift the point and e.g. shift the angle computed
+        # below from exactly zero to nonzero.
+        pos = self.get_transform().inverted().transform(screen_pos)
+        if not np.allclose(pos, xys[idx]):
+            xys = np.insert(xys, idx, pos, axis=0)
+            codes = np.insert(codes, idx, Path.LINETO)
+
+        # Find the connected component where the label will be inserted.  Note that a
+        # path always starts with a MOVETO, and we consider there's an implicit
+        # MOVETO (closing the last path) at the end.
+        movetos = (codes == Path.MOVETO).nonzero()[0]
+        start = movetos[movetos <= idx][-1]
+        try:
+            stop = movetos[movetos > idx][0]
+        except IndexError:
+            stop = len(codes)
+
+        # Restrict ourselves to the connected component.
+        cc_xys = xys[start:stop]
+        idx -= start
+
+        # If the path is closed, rotate it s.t. it starts at the label.
+        is_closed_path = codes[stop - 1] == Path.CLOSEPOLY
+        if is_closed_path:
+            cc_xys = np.concatenate([cc_xys[idx:-1], cc_xys[:idx+1]])
+            idx = 0
+
+        # Like np.interp, but additionally vectorized over fp.
+        def interp_vec(x, xp, fp): return [np.interp(x, xp, col) for col in fp.T]
+
+        # Use cumulative path lengths ("cpl") as curvilinear coordinate along contour.
+        screen_xys = self.get_transform().transform(cc_xys)
+        path_cpls = np.insert(
+            np.cumsum(np.hypot(*np.diff(screen_xys, axis=0).T)), 0, 0)
+        path_cpls -= path_cpls[idx]
+
+        # Use linear interpolation to get end coordinates of label.
+        target_cpls = np.array([-lw/2, lw/2])
+        if is_closed_path:  # For closed paths, target from the other end.
+            target_cpls[0] += (path_cpls[-1] - path_cpls[0])
+        (sx0, sx1), (sy0, sy1) = interp_vec(target_cpls, path_cpls, screen_xys)
+        angle = np.rad2deg(np.arctan2(sy1 - sy0, sx1 - sx0))  # Screen space.
+        if self.rightside_up:  # Fix angle so text is never upside-down
+            angle = (angle + 90) % 180 - 90
+
+        target_cpls += [-spacing, +spacing]  # Expand range by spacing.
+
+        # Get indices near points of interest; use -1 as out of bounds marker.
+        i0, i1 = np.interp(target_cpls, path_cpls, range(len(path_cpls)),
+                           left=-1, right=-1)
+        i0 = math.floor(i0)
+        i1 = math.ceil(i1)
+        (x0, x1), (y0, y1) = interp_vec(target_cpls, path_cpls, cc_xys)
+
+        # Actually break contours (dropping zero-len parts).
+        new_xy_blocks = []
+        new_code_blocks = []
+        if is_closed_path:
+            if i0 != -1 and i1 != -1:
+                # This is probably wrong in the case that the entire contour would
+                # be discarded, but ensures that a valid path is returned and is
+                # consistent with behavior of mpl <3.8
+                points = cc_xys[i1:i0+1]
+                new_xy_blocks.extend([[(x1, y1)], points, [(x0, y0)]])
+                nlines = len(points) + 1
+                new_code_blocks.extend([[Path.MOVETO], [Path.LINETO] * nlines])
+        else:
+            if i0 != -1:
+                new_xy_blocks.extend([cc_xys[:i0 + 1], [(x0, y0)]])
+                new_code_blocks.extend([[Path.MOVETO], [Path.LINETO] * (i0 + 1)])
+            if i1 != -1:
+                new_xy_blocks.extend([[(x1, y1)], cc_xys[i1:]])
+                new_code_blocks.extend([
+                    [Path.MOVETO], [Path.LINETO] * (len(cc_xys) - i1)])
+
+        # Back to the full path.
+        xys = np.concatenate([xys[:start], *new_xy_blocks, xys[stop:]])
+        codes = np.concatenate([codes[:start], *new_code_blocks, codes[stop:]])
+
+        return angle, Path(xys, codes)
+
+    def add_label(self, x, y, rotation, lev, cvalue):
+        """Add a contour label, respecting whether *use_clabeltext* was set."""
+        data_x, data_y = self.axes.transData.inverted().transform((x, y))
+        t = Text(
+            data_x, data_y,
+            text=self.get_text(lev, self.labelFmt),
+            rotation=rotation,
+            horizontalalignment='center', verticalalignment='center',
+            zorder=self._clabel_zorder,
+            color=self.labelMappable.to_rgba(cvalue, alpha=self.get_alpha()),
+            fontproperties=self._label_font_props,
+            clip_box=self.axes.bbox)
+        if self._use_clabeltext:
+            data_rotation, = self.axes.transData.inverted().transform_angles(
+                [rotation], [[x, y]])
+            t.set(rotation=data_rotation, transform_rotates_text=True)
+        self.labelTexts.append(t)
+        self.labelCValues.append(cvalue)
+        self.labelXYs.append((x, y))
+        # Add label to plot here - useful for manual mode label selection
+        self.axes.add_artist(t)
+
+    def add_label_near(self, x, y, inline=True, inline_spacing=5,
+                       transform=None):
+        """
+        Add a label near the point ``(x, y)``.
+
+        Parameters
+        ----------
+        x, y : float
+            The approximate location of the label.
+        inline : bool, default: True
+            If *True* remove the segment of the contour beneath the label.
+        inline_spacing : int, default: 5
+            Space in pixels to leave on each side of label when placing
+            inline. This spacing will be exact for labels at locations where
+            the contour is straight, less so for labels on curved contours.
+        transform : `.Transform` or `False`, default: ``self.axes.transData``
+            A transform applied to ``(x, y)`` before labeling.  The default
+            causes ``(x, y)`` to be interpreted as data coordinates.  `False`
+            is a synonym for `.IdentityTransform`; i.e. ``(x, y)`` should be
+            interpreted as display coordinates.
+        """
+
+        if transform is None:
+            transform = self.axes.transData
+        if transform:
+            x, y = transform.transform((x, y))
+
+        idx_level_min, idx_vtx_min, proj = self._find_nearest_contour(
+            (x, y), self.labelIndiceList)
+        path = self._paths[idx_level_min]
+        level = self.labelIndiceList.index(idx_level_min)
+        label_width = self._get_nth_label_width(level)
+        rotation, path = self._split_path_and_get_label_rotation(
+            path, idx_vtx_min, proj, label_width, inline_spacing)
+        self.add_label(*proj, rotation, self.labelLevelList[idx_level_min],
+                       self.labelCValueList[idx_level_min])
+
+        if inline:
+            self._paths[idx_level_min] = path
+
+    def pop_label(self, index=-1):
+        """Defaults to removing last label, but any index can be supplied"""
+        self.labelCValues.pop(index)
+        t = self.labelTexts.pop(index)
+        t.remove()
+
+    def labels(self, inline, inline_spacing):
+        for idx, (icon, lev, cvalue) in enumerate(zip(
+                self.labelIndiceList,
+                self.labelLevelList,
+                self.labelCValueList,
+        )):
+            trans = self.get_transform()
+            label_width = self._get_nth_label_width(idx)
+            additions = []
+            for subpath in self._paths[icon]._iter_connected_components():
+                screen_xys = trans.transform(subpath.vertices)
+                # Check if long enough for a label
+                if self.print_label(screen_xys, label_width):
+                    x, y, idx = self.locate_label(screen_xys, label_width)
+                    rotation, path = self._split_path_and_get_label_rotation(
+                        subpath, idx, (x, y),
+                        label_width, inline_spacing)
+                    self.add_label(x, y, rotation, lev, cvalue)  # Really add label.
+                    if inline:  # If inline, add new contours
+                        additions.append(path)
+                else:  # If not adding label, keep old path
+                    additions.append(subpath)
+            # After looping over all segments on a contour, replace old path by new one
+            # if inlining.
+            if inline:
+                self._paths[icon] = Path.make_compound_path(*additions)
+
+    def remove(self):
+        super().remove()
+        for text in self.labelTexts:
+            text.remove()
+
+
+def _find_closest_point_on_path(xys, p):
+    """
+    Parameters
+    ----------
+    xys : (N, 2) array-like
+        Coordinates of vertices.
+    p : (float, float)
+        Coordinates of point.
+
+    Returns
+    -------
+    d2min : float
+        Minimum square distance of *p* to *xys*.
+    proj : (float, float)
+        Projection of *p* onto *xys*.
+    imin : (int, int)
+        Consecutive indices of vertices of segment in *xys* where *proj* is.
+        Segments are considered as including their end-points; i.e. if the
+        closest point on the path is a node in *xys* with index *i*, this
+        returns ``(i-1, i)``.  For the special case where *xys* is a single
+        point, this returns ``(0, 0)``.
+    """
+    if len(xys) == 1:
+        return (((p - xys[0]) ** 2).sum(), xys[0], (0, 0))
+    dxys = xys[1:] - xys[:-1]  # Individual segment vectors.
+    norms = (dxys ** 2).sum(axis=1)
+    norms[norms == 0] = 1  # For zero-length segment, replace 0/0 by 0/1.
+    rel_projs = np.clip(  # Project onto each segment in relative 0-1 coords.
+        ((p - xys[:-1]) * dxys).sum(axis=1) / norms,
+        0, 1)[:, None]
+    projs = xys[:-1] + rel_projs * dxys  # Projs. onto each segment, in (x, y).
+    d2s = ((projs - p) ** 2).sum(axis=1)  # Squared distances.
+    imin = np.argmin(d2s)
+    return (d2s[imin], projs[imin], (imin, imin+1))
+
+
+_docstring.interpd.register(contour_set_attributes=r"""
+Attributes
+----------
+levels : array
+    The values of the contour levels.
+
+layers : array
+    Same as levels for line contours; half-way between
+    levels for filled contours.  See ``ContourSet._process_colors``.
+""")
+
+
+@_docstring.interpd
+class ContourSet(ContourLabeler, mcoll.Collection):
+    """
+    Store a set of contour lines or filled regions.
+
+    User-callable method: `~.Axes.clabel`
+
+    Parameters
+    ----------
+    ax : `~matplotlib.axes.Axes`
+
+    levels : [level0, level1, ..., leveln]
+        A list of floating point numbers indicating the contour levels.
+
+    allsegs : [level0segs, level1segs, ...]
+        List of all the polygon segments for all the *levels*.
+        For contour lines ``len(allsegs) == len(levels)``, and for
+        filled contour regions ``len(allsegs) = len(levels)-1``. The lists
+        should look like ::
+
+            level0segs = [polygon0, polygon1, ...]
+            polygon0 = [[x0, y0], [x1, y1], ...]
+
+    allkinds : ``None`` or [level0kinds, level1kinds, ...]
+        Optional list of all the polygon vertex kinds (code types), as
+        described and used in Path. This is used to allow multiply-
+        connected paths such as holes within filled polygons.
+        If not ``None``, ``len(allkinds) == len(allsegs)``. The lists
+        should look like ::
+
+            level0kinds = [polygon0kinds, ...]
+            polygon0kinds = [vertexcode0, vertexcode1, ...]
+
+        If *allkinds* is not ``None``, usually all polygons for a
+        particular contour level are grouped together so that
+        ``level0segs = [polygon0]`` and ``level0kinds = [polygon0kinds]``.
+
+    **kwargs
+        Keyword arguments are as described in the docstring of
+        `~.Axes.contour`.
+
+    %(contour_set_attributes)s
+    """
+
+    def __init__(self, ax, *args,
+                 levels=None, filled=False, linewidths=None, linestyles=None,
+                 hatches=(None,), alpha=None, origin=None, extent=None,
+                 cmap=None, colors=None, norm=None, vmin=None, vmax=None,
+                 colorizer=None, extend='neither', antialiased=None, nchunk=0,
+                 locator=None, transform=None, negative_linestyles=None, clip_path=None,
+                 **kwargs):
+        """
+        Draw contour lines or filled regions, depending on
+        whether keyword arg *filled* is ``False`` (default) or ``True``.
+
+        Call signature::
+
+            ContourSet(ax, levels, allsegs, [allkinds], **kwargs)
+
+        Parameters
+        ----------
+        ax : `~matplotlib.axes.Axes`
+            The `~.axes.Axes` object to draw on.
+
+        levels : [level0, level1, ..., leveln]
+            A list of floating point numbers indicating the contour
+            levels.
+
+        allsegs : [level0segs, level1segs, ...]
+            List of all the polygon segments for all the *levels*.
+            For contour lines ``len(allsegs) == len(levels)``, and for
+            filled contour regions ``len(allsegs) = len(levels)-1``. The lists
+            should look like ::
+
+                level0segs = [polygon0, polygon1, ...]
+                polygon0 = [[x0, y0], [x1, y1], ...]
+
+        allkinds : [level0kinds, level1kinds, ...], optional
+            Optional list of all the polygon vertex kinds (code types), as
+            described and used in Path. This is used to allow multiply-
+            connected paths such as holes within filled polygons.
+            If not ``None``, ``len(allkinds) == len(allsegs)``. The lists
+            should look like ::
+
+                level0kinds = [polygon0kinds, ...]
+                polygon0kinds = [vertexcode0, vertexcode1, ...]
+
+            If *allkinds* is not ``None``, usually all polygons for a
+            particular contour level are grouped together so that
+            ``level0segs = [polygon0]`` and ``level0kinds = [polygon0kinds]``.
+
+        **kwargs
+            Keyword arguments are as described in the docstring of
+            `~.Axes.contour`.
+        """
+        if antialiased is None and filled:
+            # Eliminate artifacts; we are not stroking the boundaries.
+            antialiased = False
+            # The default for line contours will be taken from the
+            # LineCollection default, which uses :rc:`lines.antialiased`.
+        super().__init__(
+            antialiaseds=antialiased,
+            alpha=alpha,
+            clip_path=clip_path,
+            transform=transform,
+            colorizer=colorizer,
+        )
+        self.axes = ax
+        self.levels = levels
+        self.filled = filled
+        self.hatches = hatches
+        self.origin = origin
+        self.extent = extent
+        self.colors = colors
+        self.extend = extend
+
+        self.nchunk = nchunk
+        self.locator = locator
+
+        if colorizer:
+            self._set_colorizer_check_keywords(colorizer, cmap=cmap,
+                                               norm=norm, vmin=vmin,
+                                               vmax=vmax, colors=colors)
+            norm = colorizer.norm
+            cmap = colorizer.cmap
+        if (isinstance(norm, mcolors.LogNorm)
+                or isinstance(self.locator, ticker.LogLocator)):
+            self.logscale = True
+            if norm is None:
+                norm = mcolors.LogNorm()
+        else:
+            self.logscale = False
+
+        _api.check_in_list([None, 'lower', 'upper', 'image'], origin=origin)
+        if self.extent is not None and len(self.extent) != 4:
+            raise ValueError(
+                "If given, 'extent' must be None or (x0, x1, y0, y1)")
+        if self.colors is not None and cmap is not None:
+            raise ValueError('Either colors or cmap must be None')
+        if self.origin == 'image':
+            self.origin = mpl.rcParams['image.origin']
+
+        self._orig_linestyles = linestyles  # Only kept for user access.
+        self.negative_linestyles = negative_linestyles
+        # If negative_linestyles was not defined as a keyword argument, define
+        # negative_linestyles with rcParams
+        if self.negative_linestyles is None:
+            self.negative_linestyles = \
+                mpl.rcParams['contour.negative_linestyle']
+
+        kwargs = self._process_args(*args, **kwargs)
+        self._process_levels()
+
+        self._extend_min = self.extend in ['min', 'both']
+        self._extend_max = self.extend in ['max', 'both']
+        if self.colors is not None:
+            if mcolors.is_color_like(self.colors):
+                color_sequence = [self.colors]
+            else:
+                color_sequence = self.colors
+
+            ncolors = len(self.levels)
+            if self.filled:
+                ncolors -= 1
+            i0 = 0
+
+            # Handle the case where colors are given for the extended
+            # parts of the contour.
+
+            use_set_under_over = False
+            # if we are extending the lower end, and we've been given enough
+            # colors then skip the first color in the resulting cmap. For the
+            # extend_max case we don't need to worry about passing more colors
+            # than ncolors as ListedColormap will clip.
+            total_levels = (ncolors +
+                            int(self._extend_min) +
+                            int(self._extend_max))
+            if (len(color_sequence) == total_levels and
+                    (self._extend_min or self._extend_max)):
+                use_set_under_over = True
+                if self._extend_min:
+                    i0 = 1
+
+            cmap = mcolors.ListedColormap(color_sequence[i0:None], N=ncolors)
+
+            if use_set_under_over:
+                if self._extend_min:
+                    cmap.set_under(color_sequence[0])
+                if self._extend_max:
+                    cmap.set_over(color_sequence[-1])
+
+        # label lists must be initialized here
+        self.labelTexts = []
+        self.labelCValues = []
+
+        self.set_cmap(cmap)
+        if norm is not None:
+            self.set_norm(norm)
+        with self.norm.callbacks.blocked(signal="changed"):
+            if vmin is not None:
+                self.norm.vmin = vmin
+            if vmax is not None:
+                self.norm.vmax = vmax
+        self.norm._changed()
+        self._process_colors()
+
+        if self._paths is None:
+            self._paths = self._make_paths_from_contour_generator()
+
+        if self.filled:
+            if linewidths is not None:
+                _api.warn_external('linewidths is ignored by contourf')
+            # Lower and upper contour levels.
+            lowers, uppers = self._get_lowers_and_uppers()
+            self.set(
+                edgecolor="none",
+                # Default zorder taken from Collection
+                zorder=kwargs.pop("zorder", 1),
+            )
+
+        else:
+            self.set(
+                facecolor="none",
+                linewidths=self._process_linewidths(linewidths),
+                linestyle=self._process_linestyles(linestyles),
+                # Default zorder taken from LineCollection, which is higher
+                # than for filled contours so that lines are displayed on top.
+                zorder=kwargs.pop("zorder", 2),
+                label="_nolegend_",
+            )
+
+        self.axes.add_collection(self, autolim=False)
+        self.sticky_edges.x[:] = [self._mins[0], self._maxs[0]]
+        self.sticky_edges.y[:] = [self._mins[1], self._maxs[1]]
+        self.axes.update_datalim([self._mins, self._maxs])
+        self.axes.autoscale_view(tight=True)
+
+        self.changed()  # set the colors
+
+        if kwargs:
+            _api.warn_external(
+                'The following kwargs were not used by contour: ' +
+                ", ".join(map(repr, kwargs))
+            )
+
+    allsegs = property(lambda self: [
+        [subp.vertices for subp in p._iter_connected_components()]
+        for p in self.get_paths()])
+    allkinds = property(lambda self: [
+        [subp.codes for subp in p._iter_connected_components()]
+        for p in self.get_paths()])
+    alpha = property(lambda self: self.get_alpha())
+    linestyles = property(lambda self: self._orig_linestyles)
+
+    def get_transform(self):
+        """Return the `.Transform` instance used by this ContourSet."""
+        if self._transform is None:
+            self._transform = self.axes.transData
+        elif (not isinstance(self._transform, mtransforms.Transform)
+              and hasattr(self._transform, '_as_mpl_transform')):
+            self._transform = self._transform._as_mpl_transform(self.axes)
+        return self._transform
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        # the C object _contour_generator cannot currently be pickled. This
+        # isn't a big issue as it is not actually used once the contour has
+        # been calculated.
+        state['_contour_generator'] = None
+        return state
+
+    def legend_elements(self, variable_name='x', str_format=str):
+        """
+        Return a list of artists and labels suitable for passing through
+        to `~.Axes.legend` which represent this ContourSet.
+
+        The labels have the form "0 < x <= 1" stating the data ranges which
+        the artists represent.
+
+        Parameters
+        ----------
+        variable_name : str
+            The string used inside the inequality used on the labels.
+        str_format : function: float -> str
+            Function used to format the numbers in the labels.
+
+        Returns
+        -------
+        artists : list[`.Artist`]
+            A list of the artists.
+        labels : list[str]
+            A list of the labels.
+        """
+        artists = []
+        labels = []
+
+        if self.filled:
+            lowers, uppers = self._get_lowers_and_uppers()
+            n_levels = len(self._paths)
+            for idx in range(n_levels):
+                artists.append(mpatches.Rectangle(
+                    (0, 0), 1, 1,
+                    facecolor=self.get_facecolor()[idx],
+                    hatch=self.hatches[idx % len(self.hatches)],
+                ))
+                lower = str_format(lowers[idx])
+                upper = str_format(uppers[idx])
+                if idx == 0 and self.extend in ('min', 'both'):
+                    labels.append(fr'${variable_name} \leq {lower}s$')
+                elif idx == n_levels - 1 and self.extend in ('max', 'both'):
+                    labels.append(fr'${variable_name} > {upper}s$')
+                else:
+                    labels.append(fr'${lower} < {variable_name} \leq {upper}$')
+        else:
+            for idx, level in enumerate(self.levels):
+                artists.append(Line2D(
+                    [], [],
+                    color=self.get_edgecolor()[idx],
+                    linewidth=self.get_linewidths()[idx],
+                    linestyle=self.get_linestyles()[idx],
+                ))
+                labels.append(fr'${variable_name} = {str_format(level)}$')
+
+        return artists, labels
+
+    def _process_args(self, *args, **kwargs):
+        """
+        Process *args* and *kwargs*; override in derived classes.
+
+        Must set self.levels, self.zmin and self.zmax, and update Axes limits.
+        """
+        self.levels = args[0]
+        allsegs = args[1]
+        allkinds = args[2] if len(args) > 2 else None
+        self.zmax = np.max(self.levels)
+        self.zmin = np.min(self.levels)
+
+        if allkinds is None:
+            allkinds = [[None] * len(segs) for segs in allsegs]
+
+        # Check lengths of levels and allsegs.
+        if self.filled:
+            if len(allsegs) != len(self.levels) - 1:
+                raise ValueError('must be one less number of segments as '
+                                 'levels')
+        else:
+            if len(allsegs) != len(self.levels):
+                raise ValueError('must be same number of segments as levels')
+
+        # Check length of allkinds.
+        if len(allkinds) != len(allsegs):
+            raise ValueError('allkinds has different length to allsegs')
+
+        # Determine x, y bounds and update axes data limits.
+        flatseglist = [s for seg in allsegs for s in seg]
+        points = np.concatenate(flatseglist, axis=0)
+        self._mins = points.min(axis=0)
+        self._maxs = points.max(axis=0)
+
+        # Each entry in (allsegs, allkinds) is a list of (segs, kinds): segs is a list
+        # of (N, 2) arrays of xy coordinates, kinds is a list of arrays of corresponding
+        # pathcodes.  However, kinds can also be None; in which case all paths in that
+        # list are codeless (this case is normalized above).  These lists are used to
+        # construct paths, which then get concatenated.
+        self._paths = [Path.make_compound_path(*map(Path, segs, kinds))
+                       for segs, kinds in zip(allsegs, allkinds)]
+
+        return kwargs
+
+    def _make_paths_from_contour_generator(self):
+        """Compute ``paths`` using C extension."""
+        if self._paths is not None:
+            return self._paths
+        cg = self._contour_generator
+        empty_path = Path(np.empty((0, 2)))
+        vertices_and_codes = (
+            map(cg.create_filled_contour, *self._get_lowers_and_uppers())
+            if self.filled else
+            map(cg.create_contour, self.levels))
+        return [Path(np.concatenate(vs), np.concatenate(cs)) if len(vs) else empty_path
+                for vs, cs in vertices_and_codes]
+
+    def _get_lowers_and_uppers(self):
+        """
+        Return ``(lowers, uppers)`` for filled contours.
+        """
+        lowers = self._levels[:-1]
+        if self.zmin == lowers[0]:
+            # Include minimum values in lowest interval
+            lowers = lowers.copy()  # so we don't change self._levels
+            if self.logscale:
+                lowers[0] = 0.99 * self.zmin
+            else:
+                lowers[0] -= 1
+        uppers = self._levels[1:]
+        return (lowers, uppers)
+
+    def changed(self):
+        if not hasattr(self, "cvalues"):
+            self._process_colors()  # Sets cvalues.
+        # Force an autoscale immediately because self.to_rgba() calls
+        # autoscale_None() internally with the data passed to it,
+        # so if vmin/vmax are not set yet, this would override them with
+        # content from *cvalues* rather than levels like we want
+        self.norm.autoscale_None(self.levels)
+        self.set_array(self.cvalues)
+        self.update_scalarmappable()
+        alphas = np.broadcast_to(self.get_alpha(), len(self.cvalues))
+        for label, cv, alpha in zip(self.labelTexts, self.labelCValues, alphas):
+            label.set_alpha(alpha)
+            label.set_color(self.labelMappable.to_rgba(cv))
+        super().changed()
+
+    def _autolev(self, N):
+        """
+        Select contour levels to span the data.
+
+        The target number of levels, *N*, is used only when the
+        scale is not log and default locator is used.
+
+        We need two more levels for filled contours than for
+        line contours, because for the latter we need to specify
+        the lower and upper boundary of each range. For example,
+        a single contour boundary, say at z = 0, requires only
+        one contour line, but two filled regions, and therefore
+        three levels to provide boundaries for both regions.
+        """
+        if self.locator is None:
+            if self.logscale:
+                self.locator = ticker.LogLocator()
+            else:
+                self.locator = ticker.MaxNLocator(N + 1, min_n_ticks=1)
+
+        lev = self.locator.tick_values(self.zmin, self.zmax)
+
+        try:
+            if self.locator._symmetric:
+                return lev
+        except AttributeError:
+            pass
+
+        # Trim excess levels the locator may have supplied.
+        under = np.nonzero(lev < self.zmin)[0]
+        i0 = under[-1] if len(under) else 0
+        over = np.nonzero(lev > self.zmax)[0]
+        i1 = over[0] + 1 if len(over) else len(lev)
+        if self.extend in ('min', 'both'):
+            i0 += 1
+        if self.extend in ('max', 'both'):
+            i1 -= 1
+
+        if i1 - i0 < 3:
+            i0, i1 = 0, len(lev)
+
+        return lev[i0:i1]
+
+    def _process_contour_level_args(self, args, z_dtype):
+        """
+        Determine the contour levels and store in self.levels.
+        """
+        if self.levels is None:
+            if args:
+                levels_arg = args[0]
+            elif np.issubdtype(z_dtype, bool):
+                if self.filled:
+                    levels_arg = [0, .5, 1]
+                else:
+                    levels_arg = [.5]
+            else:
+                levels_arg = 7  # Default, hard-wired.
+        else:
+            levels_arg = self.levels
+        if isinstance(levels_arg, Integral):
+            self.levels = self._autolev(levels_arg)
+        else:
+            self.levels = np.asarray(levels_arg, np.float64)
+        if self.filled and len(self.levels) < 2:
+            raise ValueError("Filled contours require at least 2 levels.")
+        if len(self.levels) > 1 and np.min(np.diff(self.levels)) <= 0.0:
+            raise ValueError("Contour levels must be increasing")
+
+    def _process_levels(self):
+        """
+        Assign values to :attr:`layers` based on :attr:`levels`,
+        adding extended layers as needed if contours are filled.
+
+        For line contours, layers simply coincide with levels;
+        a line is a thin layer.  No extended levels are needed
+        with line contours.
+        """
+        # Make a private _levels to include extended regions; we
+        # want to leave the original levels attribute unchanged.
+        # (Colorbar needs this even for line contours.)
+        self._levels = list(self.levels)
+
+        if self.logscale:
+            lower, upper = 1e-250, 1e250
+        else:
+            lower, upper = -1e250, 1e250
+
+        if self.extend in ('both', 'min'):
+            self._levels.insert(0, lower)
+        if self.extend in ('both', 'max'):
+            self._levels.append(upper)
+        self._levels = np.asarray(self._levels)
+
+        if not self.filled:
+            self.layers = self.levels
+            return
+
+        # Layer values are mid-way between levels in screen space.
+        if self.logscale:
+            # Avoid overflow by taking sqrt before multiplying.
+            self.layers = (np.sqrt(self._levels[:-1])
+                           * np.sqrt(self._levels[1:]))
+        else:
+            self.layers = 0.5 * (self._levels[:-1] + self._levels[1:])
+
+    def _process_colors(self):
+        """
+        Color argument processing for contouring.
+
+        Note that we base the colormapping on the contour levels
+        and layers, not on the actual range of the Z values.  This
+        means we don't have to worry about bad values in Z, and we
+        always have the full dynamic range available for the selected
+        levels.
+
+        The color is based on the midpoint of the layer, except for
+        extended end layers.  By default, the norm vmin and vmax
+        are the extreme values of the non-extended levels.  Hence,
+        the layer color extremes are not the extreme values of
+        the colormap itself, but approach those values as the number
+        of levels increases.  An advantage of this scheme is that
+        line contours, when added to filled contours, take on
+        colors that are consistent with those of the filled regions;
+        for example, a contour line on the boundary between two
+        regions will have a color intermediate between those
+        of the regions.
+
+        """
+        self.monochrome = self.cmap.monochrome
+        if self.colors is not None:
+            # Generate integers for direct indexing.
+            i0, i1 = 0, len(self.levels)
+            if self.filled:
+                i1 -= 1
+                # Out of range indices for over and under:
+                if self.extend in ('both', 'min'):
+                    i0 -= 1
+                if self.extend in ('both', 'max'):
+                    i1 += 1
+            self.cvalues = list(range(i0, i1))
+            self.set_norm(mcolors.NoNorm())
+        else:
+            self.cvalues = self.layers
+        self.norm.autoscale_None(self.levels)
+        self.set_array(self.cvalues)
+        self.update_scalarmappable()
+        if self.extend in ('both', 'max', 'min'):
+            self.norm.clip = False
+
+    def _process_linewidths(self, linewidths):
+        Nlev = len(self.levels)
+        if linewidths is None:
+            default_linewidth = mpl.rcParams['contour.linewidth']
+            if default_linewidth is None:
+                default_linewidth = mpl.rcParams['lines.linewidth']
+            return [default_linewidth] * Nlev
+        elif not np.iterable(linewidths):
+            return [linewidths] * Nlev
+        else:
+            linewidths = list(linewidths)
+            return (linewidths * math.ceil(Nlev / len(linewidths)))[:Nlev]
+
+    def _process_linestyles(self, linestyles):
+        Nlev = len(self.levels)
+        if linestyles is None:
+            tlinestyles = ['solid'] * Nlev
+            if self.monochrome:
+                eps = - (self.zmax - self.zmin) * 1e-15
+                for i, lev in enumerate(self.levels):
+                    if lev < eps:
+                        tlinestyles[i] = self.negative_linestyles
+        else:
+            if isinstance(linestyles, str):
+                tlinestyles = [linestyles] * Nlev
+            elif np.iterable(linestyles):
+                tlinestyles = list(linestyles)
+                if len(tlinestyles) < Nlev:
+                    nreps = int(np.ceil(Nlev / len(linestyles)))
+                    tlinestyles = tlinestyles * nreps
+                if len(tlinestyles) > Nlev:
+                    tlinestyles = tlinestyles[:Nlev]
+            else:
+                raise ValueError("Unrecognized type for linestyles kwarg")
+        return tlinestyles
+
+    def _find_nearest_contour(self, xy, indices=None):
+        """
+        Find the point in the unfilled contour plot that is closest (in screen
+        space) to point *xy*.
+
+        Parameters
+        ----------
+        xy : tuple[float, float]
+            The reference point (in screen space).
+        indices : list of int or None, default: None
+            Indices of contour levels to consider.  If None (the default), all levels
+            are considered.
+
+        Returns
+        -------
+        idx_level_min : int
+            The index of the contour level closest to *xy*.
+        idx_vtx_min : int
+            The index of the `.Path` segment closest to *xy* (at that level).
+        proj : (float, float)
+            The point in the contour plot closest to *xy*.
+        """
+
+        # Convert each contour segment to pixel coordinates and then compare the given
+        # point to those coordinates for each contour. This is fast enough in normal
+        # cases, but speedups may be possible.
+
+        if self.filled:
+            raise ValueError("Method does not support filled contours")
+
+        if indices is None:
+            indices = range(len(self._paths))
+
+        d2min = np.inf
+        idx_level_min = idx_vtx_min = proj_min = None
+
+        for idx_level in indices:
+            path = self._paths[idx_level]
+            idx_vtx_start = 0
+            for subpath in path._iter_connected_components():
+                if not len(subpath.vertices):
+                    continue
+                lc = self.get_transform().transform(subpath.vertices)
+                d2, proj, leg = _find_closest_point_on_path(lc, xy)
+                if d2 < d2min:
+                    d2min = d2
+                    idx_level_min = idx_level
+                    idx_vtx_min = leg[1] + idx_vtx_start
+                    proj_min = proj
+                idx_vtx_start += len(subpath)
+
+        return idx_level_min, idx_vtx_min, proj_min
+
+    def find_nearest_contour(self, x, y, indices=None, pixel=True):
+        """
+        Find the point in the contour plot that is closest to ``(x, y)``.
+
+        This method does not support filled contours.
+
+        Parameters
+        ----------
+        x, y : float
+            The reference point.
+        indices : list of int or None, default: None
+            Indices of contour levels to consider.  If None (the default), all
+            levels are considered.
+        pixel : bool, default: True
+            If *True*, measure distance in pixel (screen) space, which is
+            useful for manual contour labeling; else, measure distance in axes
+            space.
+
+        Returns
+        -------
+        path : int
+            The index of the path that is closest to ``(x, y)``.  Each path corresponds
+            to one contour level.
+        subpath : int
+            The index within that closest path of the subpath that is closest to
+            ``(x, y)``.  Each subpath corresponds to one unbroken contour line.
+        index : int
+            The index of the vertices within that subpath that are closest to
+            ``(x, y)``.
+        xmin, ymin : float
+            The point in the contour plot that is closest to ``(x, y)``.
+        d2 : float
+            The squared distance from ``(xmin, ymin)`` to ``(x, y)``.
+        """
+        segment = index = d2 = None
+
+        with ExitStack() as stack:
+            if not pixel:
+                # _find_nearest_contour works in pixel space. We want axes space, so
+                # effectively disable the transformation here by setting to identity.
+                stack.enter_context(self._cm_set(
+                    transform=mtransforms.IdentityTransform()))
+
+            i_level, i_vtx, (xmin, ymin) = self._find_nearest_contour((x, y), indices)
+
+        if i_level is not None:
+            cc_cumlens = np.cumsum(
+                [*map(len, self._paths[i_level]._iter_connected_components())])
+            segment = cc_cumlens.searchsorted(i_vtx, "right")
+            index = i_vtx if segment == 0 else i_vtx - cc_cumlens[segment - 1]
+            d2 = (xmin-x)**2 + (ymin-y)**2
+
+        return (i_level, segment, index, xmin, ymin, d2)
+
+    def draw(self, renderer):
+        paths = self._paths
+        n_paths = len(paths)
+        if not self.filled or all(hatch is None for hatch in self.hatches):
+            super().draw(renderer)
+            return
+        # In presence of hatching, draw contours one at a time.
+        edgecolors = self.get_edgecolors()
+        if edgecolors.size == 0:
+            edgecolors = ("none",)
+        for idx in range(n_paths):
+            with cbook._setattr_cm(self, _paths=[paths[idx]]), self._cm_set(
+                hatch=self.hatches[idx % len(self.hatches)],
+                array=[self.get_array()[idx]],
+                linewidths=[self.get_linewidths()[idx % len(self.get_linewidths())]],
+                linestyles=[self.get_linestyles()[idx % len(self.get_linestyles())]],
+                edgecolors=edgecolors[idx % len(edgecolors)],
+            ):
+                super().draw(renderer)
+
+
+@_docstring.interpd
+class QuadContourSet(ContourSet):
+    """
+    Create and store a set of contour lines or filled regions.
+
+    This class is typically not instantiated directly by the user but by
+    `~.Axes.contour` and `~.Axes.contourf`.
+
+    %(contour_set_attributes)s
+    """
+
+    def _process_args(self, *args, corner_mask=None, algorithm=None, **kwargs):
+        """
+        Process args and kwargs.
+        """
+        if args and isinstance(args[0], QuadContourSet):
+            if self.levels is None:
+                self.levels = args[0].levels
+            self.zmin = args[0].zmin
+            self.zmax = args[0].zmax
+            self._corner_mask = args[0]._corner_mask
+            contour_generator = args[0]._contour_generator
+            self._mins = args[0]._mins
+            self._maxs = args[0]._maxs
+            self._algorithm = args[0]._algorithm
+        else:
+            import contourpy
+
+            if algorithm is None:
+                algorithm = mpl.rcParams['contour.algorithm']
+            mpl.rcParams.validate["contour.algorithm"](algorithm)
+            self._algorithm = algorithm
+
+            if corner_mask is None:
+                if self._algorithm == "mpl2005":
+                    # mpl2005 does not support corner_mask=True so if not
+                    # specifically requested then disable it.
+                    corner_mask = False
+                else:
+                    corner_mask = mpl.rcParams['contour.corner_mask']
+            self._corner_mask = corner_mask
+
+            x, y, z = self._contour_args(args, kwargs)
+
+            contour_generator = contourpy.contour_generator(
+                x, y, z, name=self._algorithm, corner_mask=self._corner_mask,
+                line_type=contourpy.LineType.SeparateCode,
+                fill_type=contourpy.FillType.OuterCode,
+                chunk_size=self.nchunk)
+
+            t = self.get_transform()
+
+            # if the transform is not trans data, and some part of it
+            # contains transData, transform the xs and ys to data coordinates
+            if (t != self.axes.transData and
+                    any(t.contains_branch_seperately(self.axes.transData))):
+                trans_to_data = t - self.axes.transData
+                pts = np.vstack([x.flat, y.flat]).T
+                transformed_pts = trans_to_data.transform(pts)
+                x = transformed_pts[..., 0]
+                y = transformed_pts[..., 1]
+
+            self._mins = [ma.min(x), ma.min(y)]
+            self._maxs = [ma.max(x), ma.max(y)]
+
+        self._contour_generator = contour_generator
+
+        return kwargs
+
+    def _contour_args(self, args, kwargs):
+        if self.filled:
+            fn = 'contourf'
+        else:
+            fn = 'contour'
+        nargs = len(args)
+
+        if 0 < nargs <= 2:
+            z, *args = args
+            z = ma.asarray(z)
+            x, y = self._initialize_x_y(z)
+        elif 2 < nargs <= 4:
+            x, y, z_orig, *args = args
+            x, y, z = self._check_xyz(x, y, z_orig, kwargs)
+
+        else:
+            raise _api.nargs_error(fn, takes="from 1 to 4", given=nargs)
+        z = ma.masked_invalid(z, copy=False)
+        self.zmax = z.max().astype(float)
+        self.zmin = z.min().astype(float)
+        if self.logscale and self.zmin <= 0:
+            z = ma.masked_where(z <= 0, z)
+            _api.warn_external('Log scale: values of z <= 0 have been masked')
+            self.zmin = z.min().astype(float)
+        self._process_contour_level_args(args, z.dtype)
+        return (x, y, z)
+
+    def _check_xyz(self, x, y, z, kwargs):
+        """
+        Check that the shapes of the input arrays match; if x and y are 1D,
+        convert them to 2D using meshgrid.
+        """
+        x, y = self.axes._process_unit_info([("x", x), ("y", y)], kwargs)
+
+        x = np.asarray(x, dtype=np.float64)
+        y = np.asarray(y, dtype=np.float64)
+        z = ma.asarray(z)
+
+        if z.ndim != 2:
+            raise TypeError(f"Input z must be 2D, not {z.ndim}D")
+        if z.shape[0] < 2 or z.shape[1] < 2:
+            raise TypeError(f"Input z must be at least a (2, 2) shaped array, "
+                            f"but has shape {z.shape}")
+        Ny, Nx = z.shape
+
+        if x.ndim != y.ndim:
+            raise TypeError(f"Number of dimensions of x ({x.ndim}) and y "
+                            f"({y.ndim}) do not match")
+        if x.ndim == 1:
+            nx, = x.shape
+            ny, = y.shape
+            if nx != Nx:
+                raise TypeError(f"Length of x ({nx}) must match number of "
+                                f"columns in z ({Nx})")
+            if ny != Ny:
+                raise TypeError(f"Length of y ({ny}) must match number of "
+                                f"rows in z ({Ny})")
+            x, y = np.meshgrid(x, y)
+        elif x.ndim == 2:
+            if x.shape != z.shape:
+                raise TypeError(
+                    f"Shapes of x {x.shape} and z {z.shape} do not match")
+            if y.shape != z.shape:
+                raise TypeError(
+                    f"Shapes of y {y.shape} and z {z.shape} do not match")
+        else:
+            raise TypeError(f"Inputs x and y must be 1D or 2D, not {x.ndim}D")
+
+        return x, y, z
+
+    def _initialize_x_y(self, z):
+        """
+        Return X, Y arrays such that contour(Z) will match imshow(Z)
+        if origin is not None.
+        The center of pixel Z[i, j] depends on origin:
+        if origin is None, x = j, y = i;
+        if origin is 'lower', x = j + 0.5, y = i + 0.5;
+        if origin is 'upper', x = j + 0.5, y = Nrows - i - 0.5
+        If extent is not None, x and y will be scaled to match,
+        as in imshow.
+        If origin is None and extent is not None, then extent
+        will give the minimum and maximum values of x and y.
+        """
+        if z.ndim != 2:
+            raise TypeError(f"Input z must be 2D, not {z.ndim}D")
+        elif z.shape[0] < 2 or z.shape[1] < 2:
+            raise TypeError(f"Input z must be at least a (2, 2) shaped array, "
+                            f"but has shape {z.shape}")
+        else:
+            Ny, Nx = z.shape
+        if self.origin is None:  # Not for image-matching.
+            if self.extent is None:
+                return np.meshgrid(np.arange(Nx), np.arange(Ny))
+            else:
+                x0, x1, y0, y1 = self.extent
+                x = np.linspace(x0, x1, Nx)
+                y = np.linspace(y0, y1, Ny)
+                return np.meshgrid(x, y)
+        # Match image behavior:
+        if self.extent is None:
+            x0, x1, y0, y1 = (0, Nx, 0, Ny)
+        else:
+            x0, x1, y0, y1 = self.extent
+        dx = (x1 - x0) / Nx
+        dy = (y1 - y0) / Ny
+        x = x0 + (np.arange(Nx) + 0.5) * dx
+        y = y0 + (np.arange(Ny) + 0.5) * dy
+        if self.origin == 'upper':
+            y = y[::-1]
+        return np.meshgrid(x, y)
+
+
+_docstring.interpd.register(contour_doc="""
+`.contour` and `.contourf` draw contour lines and filled contours,
+respectively.  Except as noted, function signatures and return values
+are the same for both versions.
+
+Parameters
+----------
+X, Y : array-like, optional
+    The coordinates of the values in *Z*.
+
+    *X* and *Y* must both be 2D with the same shape as *Z* (e.g.
+    created via `numpy.meshgrid`), or they must both be 1-D such
+    that ``len(X) == N`` is the number of columns in *Z* and
+    ``len(Y) == M`` is the number of rows in *Z*.
+
+    *X* and *Y* must both be ordered monotonically.
+
+    If not given, they are assumed to be integer indices, i.e.
+    ``X = range(N)``, ``Y = range(M)``.
+
+Z : (M, N) array-like
+    The height values over which the contour is drawn.  Color-mapping is
+    controlled by *cmap*, *norm*, *vmin*, and *vmax*.
+
+levels : int or array-like, optional
+    Determines the number and positions of the contour lines / regions.
+
+    If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries
+    to automatically choose no more than *n+1* "nice" contour levels
+    between minimum and maximum numeric values of *Z*.
+
+    If array-like, draw contour lines at the specified levels.
+    The values must be in increasing order.
+
+Returns
+-------
+`~.contour.QuadContourSet`
+
+Other Parameters
+----------------
+corner_mask : bool, default: :rc:`contour.corner_mask`
+    Enable/disable corner masking, which only has an effect if *Z* is
+    a masked array.  If ``False``, any quad touching a masked point is
+    masked out.  If ``True``, only the triangular corners of quads
+    nearest those points are always masked out, other triangular
+    corners comprising three unmasked points are contoured as usual.
+
+colors : :mpltype:`color` or list of :mpltype:`color`, optional
+    The colors of the levels, i.e. the lines for `.contour` and the
+    areas for `.contourf`.
+
+    The sequence is cycled for the levels in ascending order. If the
+    sequence is shorter than the number of levels, it's repeated.
+
+    As a shortcut, a single color may be used in place of one-element lists, i.e.
+    ``'red'`` instead of ``['red']`` to color all levels with the same color.
+
+    .. versionchanged:: 3.10
+        Previously a single color had to be expressed as a string, but now any
+        valid color format may be passed.
+
+    By default (value *None*), the colormap specified by *cmap*
+    will be used.
+
+alpha : float, default: 1
+    The alpha blending value, between 0 (transparent) and 1 (opaque).
+
+%(cmap_doc)s
+
+    This parameter is ignored if *colors* is set.
+
+%(norm_doc)s
+
+    This parameter is ignored if *colors* is set.
+
+%(vmin_vmax_doc)s
+
+    If *vmin* or *vmax* are not given, the default color scaling is based on
+    *levels*.
+
+    This parameter is ignored if *colors* is set.
+
+%(colorizer_doc)s
+
+    This parameter is ignored if *colors* is set.
+
+origin : {*None*, 'upper', 'lower', 'image'}, default: None
+    Determines the orientation and exact position of *Z* by specifying
+    the position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y*
+    are not given.
+
+    - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.
+    - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.
+    - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left
+      corner.
+    - 'image': Use the value from :rc:`image.origin`.
+
+extent : (x0, x1, y0, y1), optional
+    If *origin* is not *None*, then *extent* is interpreted as in
+    `.imshow`: it gives the outer pixel boundaries. In this case, the
+    position of Z[0, 0] is the center of the pixel, not a corner. If
+    *origin* is *None*, then (*x0*, *y0*) is the position of Z[0, 0],
+    and (*x1*, *y1*) is the position of Z[-1, -1].
+
+    This argument is ignored if *X* and *Y* are specified in the call
+    to contour.
+
+locator : ticker.Locator subclass, optional
+    The locator is used to determine the contour levels if they
+    are not given explicitly via *levels*.
+    Defaults to `~.ticker.MaxNLocator`.
+
+extend : {'neither', 'both', 'min', 'max'}, default: 'neither'
+    Determines the ``contourf``-coloring of values that are outside the
+    *levels* range.
+
+    If 'neither', values outside the *levels* range are not colored.
+    If 'min', 'max' or 'both', color the values below, above or below
+    and above the *levels* range.
+
+    Values below ``min(levels)`` and above ``max(levels)`` are mapped
+    to the under/over values of the `.Colormap`. Note that most
+    colormaps do not have dedicated colors for these by default, so
+    that the over and under values are the edge values of the colormap.
+    You may want to set these values explicitly using
+    `.Colormap.set_under` and `.Colormap.set_over`.
+
+    .. note::
+
+        An existing `.QuadContourSet` does not get notified if
+        properties of its colormap are changed. Therefore, an explicit
+        call `~.ContourSet.changed()` is needed after modifying the
+        colormap. The explicit call can be left out, if a colorbar is
+        assigned to the `.QuadContourSet` because it internally calls
+        `~.ContourSet.changed()`.
+
+    Example::
+
+        x = np.arange(1, 10)
+        y = x.reshape(-1, 1)
+        h = x * y
+
+        cs = plt.contourf(h, levels=[10, 30, 50],
+            colors=['#808080', '#A0A0A0', '#C0C0C0'], extend='both')
+        cs.cmap.set_over('red')
+        cs.cmap.set_under('blue')
+        cs.changed()
+
+xunits, yunits : registered units, optional
+    Override axis units by specifying an instance of a
+    :class:`matplotlib.units.ConversionInterface`.
+
+antialiased : bool, optional
+    Enable antialiasing, overriding the defaults.  For
+    filled contours, the default is *False*.  For line contours,
+    it is taken from :rc:`lines.antialiased`.
+
+nchunk : int >= 0, optional
+    If 0, no subdivision of the domain.  Specify a positive integer to
+    divide the domain into subdomains of *nchunk* by *nchunk* quads.
+    Chunking reduces the maximum length of polygons generated by the
+    contouring algorithm which reduces the rendering workload passed
+    on to the backend and also requires slightly less RAM.  It can
+    however introduce rendering artifacts at chunk boundaries depending
+    on the backend, the *antialiased* flag and value of *alpha*.
+
+linewidths : float or array-like, default: :rc:`contour.linewidth`
+    *Only applies to* `.contour`.
+
+    The line width of the contour lines.
+
+    If a number, all levels will be plotted with this linewidth.
+
+    If a sequence, the levels in ascending order will be plotted with
+    the linewidths in the order specified.
+
+    If None, this falls back to :rc:`lines.linewidth`.
+
+linestyles : {*None*, 'solid', 'dashed', 'dashdot', 'dotted'}, optional
+    *Only applies to* `.contour`.
+
+    If *linestyles* is *None*, the default is 'solid' unless the lines are
+    monochrome. In that case, negative contours will instead take their
+    linestyle from the *negative_linestyles* argument.
+
+    *linestyles* can also be an iterable of the above strings specifying a set
+    of linestyles to be used. If this iterable is shorter than the number of
+    contour levels it will be repeated as necessary.
+
+negative_linestyles : {*None*, 'solid', 'dashed', 'dashdot', 'dotted'}, \
+                       optional
+    *Only applies to* `.contour`.
+
+    If *linestyles* is *None* and the lines are monochrome, this argument
+    specifies the line style for negative contours.
+
+    If *negative_linestyles* is *None*, the default is taken from
+    :rc:`contour.negative_linestyle`.
+
+    *negative_linestyles* can also be an iterable of the above strings
+    specifying a set of linestyles to be used. If this iterable is shorter than
+    the number of contour levels it will be repeated as necessary.
+
+hatches : list[str], optional
+    *Only applies to* `.contourf`.
+
+    A list of cross hatch patterns to use on the filled areas.
+    If None, no hatching will be added to the contour.
+
+algorithm : {'mpl2005', 'mpl2014', 'serial', 'threaded'}, optional
+    Which contouring algorithm to use to calculate the contour lines and
+    polygons. The algorithms are implemented in
+    `ContourPy <https://github.com/contourpy/contourpy>`_, consult the
+    `ContourPy documentation <https://contourpy.readthedocs.io>`_ for
+    further information.
+
+    The default is taken from :rc:`contour.algorithm`.
+
+clip_path : `~matplotlib.patches.Patch` or `.Path` or `.TransformedPath`
+    Set the clip path.  See `~matplotlib.artist.Artist.set_clip_path`.
+
+    .. versionadded:: 3.8
+
+data : indexable object, optional
+    DATA_PARAMETER_PLACEHOLDER
+
+Notes
+-----
+1. `.contourf` differs from the MATLAB version in that it does not draw
+   the polygon edges. To draw edges, add line contours with calls to
+   `.contour`.
+
+2. `.contourf` fills intervals that are closed at the top; that is, for
+   boundaries *z1* and *z2*, the filled region is::
+
+      z1 < Z <= z2
+
+   except for the lowest interval, which is closed on both sides (i.e.
+   it includes the lowest value).
+
+3. `.contour` and `.contourf` use a `marching squares
+   <https://en.wikipedia.org/wiki/Marching_squares>`_ algorithm to
+   compute contour locations.  More information can be found in
+   `ContourPy documentation <https://contourpy.readthedocs.io>`_.
+""" % _docstring.interpd.params)

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/contour.pyi

@@ -0,0 +1,140 @@
+import matplotlib.cm as cm
+from matplotlib.artist import Artist
+from matplotlib.axes import Axes
+from matplotlib.collections import Collection, PathCollection
+from matplotlib.colorizer import Colorizer, ColorizingArtist
+from matplotlib.colors import Colormap, Normalize
+from matplotlib.path import Path
+from matplotlib.patches import Patch
+from matplotlib.text import Text
+from matplotlib.transforms import Transform, TransformedPatchPath, TransformedPath
+from matplotlib.ticker import Locator, Formatter
+
+from numpy.typing import ArrayLike
+import numpy as np
+from collections.abc import Callable, Iterable, Sequence
+from typing import Literal
+from .typing import ColorType
+
+
+
+class ContourLabeler:
+    labelFmt: str | Formatter | Callable[[float], str] | dict[float, str]
+    labelManual: bool | Iterable[tuple[float, float]]
+    rightside_up: bool
+    labelLevelList: list[float]
+    labelIndiceList: list[int]
+    labelMappable: cm.ScalarMappable | ColorizingArtist
+    labelCValueList: list[ColorType]
+    labelXYs: list[tuple[float, float]]
+    def clabel(
+        self,
+        levels: ArrayLike | None = ...,
+        *,
+        fontsize: str | float | None = ...,
+        inline: bool = ...,
+        inline_spacing: float = ...,
+        fmt: str | Formatter | Callable[[float], str] | dict[float, str] | None = ...,
+        colors: ColorType | Sequence[ColorType] | None = ...,
+        use_clabeltext: bool = ...,
+        manual: bool | Iterable[tuple[float, float]] = ...,
+        rightside_up: bool = ...,
+        zorder: float | None = ...
+    ) -> list[Text]: ...
+    def print_label(self, linecontour: ArrayLike, labelwidth: float) -> bool: ...
+    def too_close(self, x: float, y: float, lw: float) -> bool: ...
+    def get_text(
+        self,
+        lev: float,
+        fmt: str | Formatter | Callable[[float], str] | dict[float, str],
+    ) -> str: ...
+    def locate_label(
+        self, linecontour: ArrayLike, labelwidth: float
+    ) -> tuple[float, float, float]: ...
+    def add_label(
+        self, x: float, y: float, rotation: float, lev: float, cvalue: ColorType
+    ) -> None: ...
+    def add_label_near(
+        self,
+        x: float,
+        y: float,
+        inline: bool = ...,
+        inline_spacing: int = ...,
+        transform: Transform | Literal[False] | None = ...,
+    ) -> None: ...
+    def pop_label(self, index: int = ...) -> None: ...
+    def labels(self, inline: bool, inline_spacing: int) -> None: ...
+    def remove(self) -> None: ...
+
+class ContourSet(ContourLabeler, Collection):
+    axes: Axes
+    levels: Iterable[float]
+    filled: bool
+    linewidths: float | ArrayLike | None
+    hatches: Iterable[str | None]
+    origin: Literal["upper", "lower", "image"] | None
+    extent: tuple[float, float, float, float] | None
+    colors: ColorType | Sequence[ColorType]
+    extend: Literal["neither", "both", "min", "max"]
+    nchunk: int
+    locator: Locator | None
+    logscale: bool
+    negative_linestyles: None | Literal[
+        "solid", "dashed", "dashdot", "dotted"
+    ] | Iterable[Literal["solid", "dashed", "dashdot", "dotted"]]
+    clip_path: Patch | Path | TransformedPath | TransformedPatchPath | None
+    labelTexts: list[Text]
+    labelCValues: list[ColorType]
+
+    @property
+    def allkinds(self) -> list[list[np.ndarray | None]]: ...
+    @property
+    def allsegs(self) -> list[list[np.ndarray]]: ...
+    @property
+    def alpha(self) -> float | None: ...
+    @property
+    def linestyles(self) -> (
+        None |
+        Literal["solid", "dashed", "dashdot", "dotted"] |
+        Iterable[Literal["solid", "dashed", "dashdot", "dotted"]]
+    ): ...
+
+    def __init__(
+        self,
+        ax: Axes,
+        *args,
+        levels: Iterable[float] | None = ...,
+        filled: bool = ...,
+        linewidths: float | ArrayLike | None = ...,
+        linestyles: Literal["solid", "dashed", "dashdot", "dotted"]
+        | Iterable[Literal["solid", "dashed", "dashdot", "dotted"]]
+        | None = ...,
+        hatches: Iterable[str | None] = ...,
+        alpha: float | None = ...,
+        origin: Literal["upper", "lower", "image"] | None = ...,
+        extent: tuple[float, float, float, float] | None = ...,
+        cmap: str | Colormap | None = ...,
+        colors: ColorType | Sequence[ColorType] | None = ...,
+        norm: str | Normalize | None = ...,
+        vmin: float | None = ...,
+        vmax: float | None = ...,
+        colorizer: Colorizer | None = ...,
+        extend: Literal["neither", "both", "min", "max"] = ...,
+        antialiased: bool | None = ...,
+        nchunk: int = ...,
+        locator: Locator | None = ...,
+        transform: Transform | None = ...,
+        negative_linestyles: Literal["solid", "dashed", "dashdot", "dotted"]
+        | Iterable[Literal["solid", "dashed", "dashdot", "dotted"]]
+        | None = ...,
+        clip_path: Patch | Path | TransformedPath | TransformedPatchPath | None = ...,
+        **kwargs
+    ) -> None: ...
+    def legend_elements(
+        self, variable_name: str = ..., str_format: Callable[[float], str] = ...
+    ) -> tuple[list[Artist], list[str]]: ...
+    def find_nearest_contour(
+        self, x: float, y: float, indices: Iterable[int] | None = ..., pixel: bool = ...
+    ) -> tuple[int, int, int, float, float, float]: ...
+
+class QuadContourSet(ContourSet): ...

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/dates.py

@@ -0,0 +1,1840 @@
+"""
+Matplotlib provides sophisticated date plotting capabilities, standing on the
+shoulders of python :mod:`datetime` and the add-on module dateutil_.
+
+By default, Matplotlib uses the units machinery described in
+`~matplotlib.units` to convert `datetime.datetime`, and `numpy.datetime64`
+objects when plotted on an x- or y-axis. The user does not
+need to do anything for dates to be formatted, but dates often have strict
+formatting needs, so this module provides many tick locators and formatters.
+A basic example using `numpy.datetime64` is::
+
+    import numpy as np
+
+    times = np.arange(np.datetime64('2001-01-02'),
+                      np.datetime64('2002-02-03'), np.timedelta64(75, 'm'))
+    y = np.random.randn(len(times))
+
+    fig, ax = plt.subplots()
+    ax.plot(times, y)
+
+.. seealso::
+
+    - :doc:`/gallery/text_labels_and_annotations/date`
+    - :doc:`/gallery/ticks/date_concise_formatter`
+    - :doc:`/gallery/ticks/date_demo_convert`
+
+.. _date-format:
+
+Matplotlib date format
+----------------------
+
+Matplotlib represents dates using floating point numbers specifying the number
+of days since a default epoch of 1970-01-01 UTC; for example,
+1970-01-01, 06:00 is the floating point number 0.25. The formatters and
+locators require the use of `datetime.datetime` objects, so only dates between
+year 0001 and 9999 can be represented.  Microsecond precision
+is achievable for (approximately) 70 years on either side of the epoch, and
+20 microseconds for the rest of the allowable range of dates (year 0001 to
+9999). The epoch can be changed at import time via `.dates.set_epoch` or
+:rc:`date.epoch` to other dates if necessary; see
+:doc:`/gallery/ticks/date_precision_and_epochs` for a discussion.
+
+.. note::
+
+   Before Matplotlib 3.3, the epoch was 0000-12-31 which lost modern
+   microsecond precision and also made the default axis limit of 0 an invalid
+   datetime.  In 3.3 the epoch was changed as above.  To convert old
+   ordinal floats to the new epoch, users can do::
+
+     new_ordinal = old_ordinal + mdates.date2num(np.datetime64('0000-12-31'))
+
+
+There are a number of helper functions to convert between :mod:`datetime`
+objects and Matplotlib dates:
+
+.. currentmodule:: matplotlib.dates
+
+.. autosummary::
+   :nosignatures:
+
+   datestr2num
+   date2num
+   num2date
+   num2timedelta
+   drange
+   set_epoch
+   get_epoch
+
+.. note::
+
+   Like Python's `datetime.datetime`, Matplotlib uses the Gregorian calendar
+   for all conversions between dates and floating point numbers. This practice
+   is not universal, and calendar differences can cause confusing
+   differences between what Python and Matplotlib give as the number of days
+   since 0001-01-01 and what other software and databases yield.  For
+   example, the US Naval Observatory uses a calendar that switches
+   from Julian to Gregorian in October, 1582.  Hence, using their
+   calculator, the number of days between 0001-01-01 and 2006-04-01 is
+   732403, whereas using the Gregorian calendar via the datetime
+   module we find::
+
+     In [1]: date(2006, 4, 1).toordinal() - date(1, 1, 1).toordinal()
+     Out[1]: 732401
+
+All the Matplotlib date converters, locators and formatters are timezone aware.
+If no explicit timezone is provided, :rc:`timezone` is assumed, provided as a
+string.  If you want to use a different timezone, pass the *tz* keyword
+argument of `num2date` to any date tick locators or formatters you create. This
+can be either a `datetime.tzinfo` instance or a string with the timezone name
+that can be parsed by `~dateutil.tz.gettz`.
+
+A wide range of specific and general purpose date tick locators and
+formatters are provided in this module.  See
+:mod:`matplotlib.ticker` for general information on tick locators
+and formatters.  These are described below.
+
+The dateutil_ module provides additional code to handle date ticking, making it
+easy to place ticks on any kinds of dates.  See examples below.
+
+.. _dateutil: https://dateutil.readthedocs.io
+
+.. _date-locators:
+
+Date tick locators
+------------------
+
+Most of the date tick locators can locate single or multiple ticks. For example::
+
+    # import constants for the days of the week
+    from matplotlib.dates import MO, TU, WE, TH, FR, SA, SU
+
+    # tick on Mondays every week
+    loc = WeekdayLocator(byweekday=MO, tz=tz)
+
+    # tick on Mondays and Saturdays
+    loc = WeekdayLocator(byweekday=(MO, SA))
+
+In addition, most of the constructors take an interval argument::
+
+    # tick on Mondays every second week
+    loc = WeekdayLocator(byweekday=MO, interval=2)
+
+The rrule locator allows completely general date ticking::
+
+    # tick every 5th easter
+    rule = rrulewrapper(YEARLY, byeaster=1, interval=5)
+    loc = RRuleLocator(rule)
+
+The available date tick locators are:
+
+* `MicrosecondLocator`: Locate microseconds.
+
+* `SecondLocator`: Locate seconds.
+
+* `MinuteLocator`: Locate minutes.
+
+* `HourLocator`: Locate hours.
+
+* `DayLocator`: Locate specified days of the month.
+
+* `WeekdayLocator`: Locate days of the week, e.g., MO, TU.
+
+* `MonthLocator`: Locate months, e.g., 7 for July.
+
+* `YearLocator`: Locate years that are multiples of base.
+
+* `RRuleLocator`: Locate using a `rrulewrapper`.
+  `rrulewrapper` is a simple wrapper around dateutil_'s `dateutil.rrule`
+  which allow almost arbitrary date tick specifications.
+  See :doc:`rrule example </gallery/ticks/date_demo_rrule>`.
+
+* `AutoDateLocator`: On autoscale, this class picks the best `DateLocator`
+  (e.g., `RRuleLocator`) to set the view limits and the tick locations.  If
+  called with ``interval_multiples=True`` it will make ticks line up with
+  sensible multiples of the tick intervals.  For example, if the interval is
+  4 hours, it will pick hours 0, 4, 8, etc. as ticks.  This behaviour is not
+  guaranteed by default.
+
+.. _date-formatters:
+
+Date formatters
+---------------
+
+The available date formatters are:
+
+* `AutoDateFormatter`: attempts to figure out the best format to use.  This is
+  most useful when used with the `AutoDateLocator`.
+
+* `ConciseDateFormatter`: also attempts to figure out the best format to use,
+  and to make the format as compact as possible while still having complete
+  date information.  This is most useful when used with the `AutoDateLocator`.
+
+* `DateFormatter`: use `~datetime.datetime.strftime` format strings.
+"""
+
+import datetime
+import functools
+import logging
+import re
+
+from dateutil.rrule import (rrule, MO, TU, WE, TH, FR, SA, SU, YEARLY,
+                            MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY,
+                            SECONDLY)
+from dateutil.relativedelta import relativedelta
+import dateutil.parser
+import dateutil.tz
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib import _api, cbook, ticker, units
+
+__all__ = ('datestr2num', 'date2num', 'num2date', 'num2timedelta', 'drange',
+           'set_epoch', 'get_epoch', 'DateFormatter', 'ConciseDateFormatter',
+           'AutoDateFormatter', 'DateLocator', 'RRuleLocator',
+           'AutoDateLocator', 'YearLocator', 'MonthLocator', 'WeekdayLocator',
+           'DayLocator', 'HourLocator', 'MinuteLocator',
+           'SecondLocator', 'MicrosecondLocator',
+           'rrule', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU',
+           'YEARLY', 'MONTHLY', 'WEEKLY', 'DAILY',
+           'HOURLY', 'MINUTELY', 'SECONDLY', 'MICROSECONDLY', 'relativedelta',
+           'DateConverter', 'ConciseDateConverter', 'rrulewrapper')
+
+
+_log = logging.getLogger(__name__)
+UTC = datetime.timezone.utc
+
+
+def _get_tzinfo(tz=None):
+    """
+    Generate `~datetime.tzinfo` from a string or return `~datetime.tzinfo`.
+    If None, retrieve the preferred timezone from the rcParams dictionary.
+    """
+    tz = mpl._val_or_rc(tz, 'timezone')
+    if tz == 'UTC':
+        return UTC
+    if isinstance(tz, str):
+        tzinfo = dateutil.tz.gettz(tz)
+        if tzinfo is None:
+            raise ValueError(f"{tz} is not a valid timezone as parsed by"
+                             " dateutil.tz.gettz.")
+        return tzinfo
+    if isinstance(tz, datetime.tzinfo):
+        return tz
+    raise TypeError(f"tz must be string or tzinfo subclass, not {tz!r}.")
+
+
+# Time-related constants.
+EPOCH_OFFSET = float(datetime.datetime(1970, 1, 1).toordinal())
+# EPOCH_OFFSET is not used by matplotlib
+MICROSECONDLY = SECONDLY + 1
+HOURS_PER_DAY = 24.
+MIN_PER_HOUR = 60.
+SEC_PER_MIN = 60.
+MONTHS_PER_YEAR = 12.
+
+DAYS_PER_WEEK = 7.
+DAYS_PER_MONTH = 30.
+DAYS_PER_YEAR = 365.0
+
+MINUTES_PER_DAY = MIN_PER_HOUR * HOURS_PER_DAY
+
+SEC_PER_HOUR = SEC_PER_MIN * MIN_PER_HOUR
+SEC_PER_DAY = SEC_PER_HOUR * HOURS_PER_DAY
+SEC_PER_WEEK = SEC_PER_DAY * DAYS_PER_WEEK
+
+MUSECONDS_PER_DAY = 1e6 * SEC_PER_DAY
+
+MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY = (
+    MO, TU, WE, TH, FR, SA, SU)
+WEEKDAYS = (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY)
+
+# default epoch: passed to np.datetime64...
+_epoch = None
+
+
+def _reset_epoch_test_example():
+    """
+    Reset the Matplotlib date epoch so it can be set again.
+
+    Only for use in tests and examples.
+    """
+    global _epoch
+    _epoch = None
+
+
+def set_epoch(epoch):
+    """
+    Set the epoch (origin for dates) for datetime calculations.
+
+    The default epoch is :rc:`date.epoch`.
+
+    If microsecond accuracy is desired, the date being plotted needs to be
+    within approximately 70 years of the epoch. Matplotlib internally
+    represents dates as days since the epoch, so floating point dynamic
+    range needs to be within a factor of 2^52.
+
+    `~.dates.set_epoch` must be called before any dates are converted
+    (i.e. near the import section) or a RuntimeError will be raised.
+
+    See also :doc:`/gallery/ticks/date_precision_and_epochs`.
+
+    Parameters
+    ----------
+    epoch : str
+        valid UTC date parsable by `numpy.datetime64` (do not include
+        timezone).
+
+    """
+    global _epoch
+    if _epoch is not None:
+        raise RuntimeError('set_epoch must be called before dates plotted.')
+    _epoch = epoch
+
+
+def get_epoch():
+    """
+    Get the epoch used by `.dates`.
+
+    Returns
+    -------
+    epoch : str
+        String for the epoch (parsable by `numpy.datetime64`).
+    """
+    global _epoch
+
+    _epoch = mpl._val_or_rc(_epoch, 'date.epoch')
+    return _epoch
+
+
+def _dt64_to_ordinalf(d):
+    """
+    Convert `numpy.datetime64` or an `numpy.ndarray` of those types to
+    Gregorian date as UTC float relative to the epoch (see `.get_epoch`).
+    Roundoff is float64 precision.  Practically: microseconds for dates
+    between 290301 BC, 294241 AD, milliseconds for larger dates
+    (see `numpy.datetime64`).
+    """
+
+    # the "extra" ensures that we at least allow the dynamic range out to
+    # seconds.  That should get out to +/-2e11 years.
+    dseconds = d.astype('datetime64[s]')
+    extra = (d - dseconds).astype('timedelta64[ns]')
+    t0 = np.datetime64(get_epoch(), 's')
+    dt = (dseconds - t0).astype(np.float64)
+    dt += extra.astype(np.float64) / 1.0e9
+    dt = dt / SEC_PER_DAY
+
+    NaT_int = np.datetime64('NaT').astype(np.int64)
+    d_int = d.astype(np.int64)
+    dt[d_int == NaT_int] = np.nan
+    return dt
+
+
+def _from_ordinalf(x, tz=None):
+    """
+    Convert Gregorian float of the date, preserving hours, minutes,
+    seconds and microseconds.  Return value is a `.datetime`.
+
+    The input date *x* is a float in ordinal days at UTC, and the output will
+    be the specified `.datetime` object corresponding to that time in
+    timezone *tz*, or if *tz* is ``None``, in the timezone specified in
+    :rc:`timezone`.
+    """
+
+    tz = _get_tzinfo(tz)
+
+    dt = (np.datetime64(get_epoch()) +
+          np.timedelta64(int(np.round(x * MUSECONDS_PER_DAY)), 'us'))
+    if dt < np.datetime64('0001-01-01') or dt >= np.datetime64('10000-01-01'):
+        raise ValueError(f'Date ordinal {x} converts to {dt} (using '
+                         f'epoch {get_epoch()}), but Matplotlib dates must be '
+                          'between year 0001 and 9999.')
+    # convert from datetime64 to datetime:
+    dt = dt.tolist()
+
+    # datetime64 is always UTC:
+    dt = dt.replace(tzinfo=dateutil.tz.gettz('UTC'))
+    # but maybe we are working in a different timezone so move.
+    dt = dt.astimezone(tz)
+    # fix round off errors
+    if np.abs(x) > 70 * 365:
+        # if x is big, round off to nearest twenty microseconds.
+        # This avoids floating point roundoff error
+        ms = round(dt.microsecond / 20) * 20
+        if ms == 1000000:
+            dt = dt.replace(microsecond=0) + datetime.timedelta(seconds=1)
+        else:
+            dt = dt.replace(microsecond=ms)
+
+    return dt
+
+
+# a version of _from_ordinalf that can operate on numpy arrays
+_from_ordinalf_np_vectorized = np.vectorize(_from_ordinalf, otypes="O")
+# a version of dateutil.parser.parse that can operate on numpy arrays
+_dateutil_parser_parse_np_vectorized = np.vectorize(dateutil.parser.parse)
+
+
+def datestr2num(d, default=None):
+    """
+    Convert a date string to a datenum using `dateutil.parser.parse`.
+
+    Parameters
+    ----------
+    d : str or sequence of str
+        The dates to convert.
+
+    default : datetime.datetime, optional
+        The default date to use when fields are missing in *d*.
+    """
+    if isinstance(d, str):
+        dt = dateutil.parser.parse(d, default=default)
+        return date2num(dt)
+    else:
+        if default is not None:
+            d = [date2num(dateutil.parser.parse(s, default=default))
+                 for s in d]
+            return np.asarray(d)
+        d = np.asarray(d)
+        if not d.size:
+            return d
+        return date2num(_dateutil_parser_parse_np_vectorized(d))
+
+
+def date2num(d):
+    """
+    Convert datetime objects to Matplotlib dates.
+
+    Parameters
+    ----------
+    d : `datetime.datetime` or `numpy.datetime64` or sequences of these
+
+    Returns
+    -------
+    float or sequence of floats
+        Number of days since the epoch.  See `.get_epoch` for the
+        epoch, which can be changed by :rc:`date.epoch` or `.set_epoch`.  If
+        the epoch is "1970-01-01T00:00:00" (default) then noon Jan 1 1970
+        ("1970-01-01T12:00:00") returns 0.5.
+
+    Notes
+    -----
+    The Gregorian calendar is assumed; this is not universal practice.
+    For details see the module docstring.
+    """
+    # Unpack in case of e.g. Pandas or xarray object
+    d = cbook._unpack_to_numpy(d)
+
+    # make an iterable, but save state to unpack later:
+    iterable = np.iterable(d)
+    if not iterable:
+        d = [d]
+
+    masked = np.ma.is_masked(d)
+    mask = np.ma.getmask(d)
+    d = np.asarray(d)
+
+    # convert to datetime64 arrays, if not already:
+    if not np.issubdtype(d.dtype, np.datetime64):
+        # datetime arrays
+        if not d.size:
+            # deals with an empty array...
+            return d
+        tzi = getattr(d[0], 'tzinfo', None)
+        if tzi is not None:
+            # make datetime naive:
+            d = [dt.astimezone(UTC).replace(tzinfo=None) for dt in d]
+            d = np.asarray(d)
+        d = d.astype('datetime64[us]')
+
+    d = np.ma.masked_array(d, mask=mask) if masked else d
+    d = _dt64_to_ordinalf(d)
+
+    return d if iterable else d[0]
+
+
+def num2date(x, tz=None):
+    """
+    Convert Matplotlib dates to `~datetime.datetime` objects.
+
+    Parameters
+    ----------
+    x : float or sequence of floats
+        Number of days (fraction part represents hours, minutes, seconds)
+        since the epoch.  See `.get_epoch` for the
+        epoch, which can be changed by :rc:`date.epoch` or `.set_epoch`.
+    tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+        Timezone of *x*. If a string, *tz* is passed to `dateutil.tz`.
+
+    Returns
+    -------
+    `~datetime.datetime` or sequence of `~datetime.datetime`
+        Dates are returned in timezone *tz*.
+
+        If *x* is a sequence, a sequence of `~datetime.datetime` objects will
+        be returned.
+
+    Notes
+    -----
+    The Gregorian calendar is assumed; this is not universal practice.
+    For details, see the module docstring.
+    """
+    tz = _get_tzinfo(tz)
+    return _from_ordinalf_np_vectorized(x, tz).tolist()
+
+
+_ordinalf_to_timedelta_np_vectorized = np.vectorize(
+    lambda x: datetime.timedelta(days=x), otypes="O")
+
+
+def num2timedelta(x):
+    """
+    Convert number of days to a `~datetime.timedelta` object.
+
+    If *x* is a sequence, a sequence of `~datetime.timedelta` objects will
+    be returned.
+
+    Parameters
+    ----------
+    x : float, sequence of floats
+        Number of days. The fraction part represents hours, minutes, seconds.
+
+    Returns
+    -------
+    `datetime.timedelta` or list[`datetime.timedelta`]
+    """
+    return _ordinalf_to_timedelta_np_vectorized(x).tolist()
+
+
+def drange(dstart, dend, delta):
+    """
+    Return a sequence of equally spaced Matplotlib dates.
+
+    The dates start at *dstart* and reach up to, but not including *dend*.
+    They are spaced by *delta*.
+
+    Parameters
+    ----------
+    dstart, dend : `~datetime.datetime`
+        The date limits.
+    delta : `datetime.timedelta`
+        Spacing of the dates.
+
+    Returns
+    -------
+    `numpy.array`
+        A list floats representing Matplotlib dates.
+
+    """
+    f1 = date2num(dstart)
+    f2 = date2num(dend)
+    step = delta.total_seconds() / SEC_PER_DAY
+
+    # calculate the difference between dend and dstart in times of delta
+    num = int(np.ceil((f2 - f1) / step))
+
+    # calculate end of the interval which will be generated
+    dinterval_end = dstart + num * delta
+
+    # ensure, that an half open interval will be generated [dstart, dend)
+    if dinterval_end >= dend:
+        # if the endpoint is greater than or equal to dend,
+        # just subtract one delta
+        dinterval_end -= delta
+        num -= 1
+
+    f2 = date2num(dinterval_end)  # new float-endpoint
+    return np.linspace(f1, f2, num + 1)
+
+
+def _wrap_in_tex(text):
+    p = r'([a-zA-Z]+)'
+    ret_text = re.sub(p, r'}$\1$\\mathdefault{', text)
+
+    # Braces ensure symbols are not spaced like binary operators.
+    ret_text = ret_text.replace('-', '{-}').replace(':', '{:}')
+    # To not concatenate space between numbers.
+    ret_text = ret_text.replace(' ', r'\;')
+    ret_text = '$\\mathdefault{' + ret_text + '}$'
+    ret_text = ret_text.replace('$\\mathdefault{}$', '')
+    return ret_text
+
+
+## date tick locators and formatters ###
+
+
+class DateFormatter(ticker.Formatter):
+    """
+    Format a tick (in days since the epoch) with a
+    `~datetime.datetime.strftime` format string.
+    """
+
+    def __init__(self, fmt, tz=None, *, usetex=None):
+        """
+        Parameters
+        ----------
+        fmt : str
+            `~datetime.datetime.strftime` format string
+        tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+            Ticks timezone. If a string, *tz* is passed to `dateutil.tz`.
+        usetex : bool, default: :rc:`text.usetex`
+            To enable/disable the use of TeX's math mode for rendering the
+            results of the formatter.
+        """
+        self.tz = _get_tzinfo(tz)
+        self.fmt = fmt
+        self._usetex = mpl._val_or_rc(usetex, 'text.usetex')
+
+    def __call__(self, x, pos=0):
+        result = num2date(x, self.tz).strftime(self.fmt)
+        return _wrap_in_tex(result) if self._usetex else result
+
+    def set_tzinfo(self, tz):
+        self.tz = _get_tzinfo(tz)
+
+
+class ConciseDateFormatter(ticker.Formatter):
+    """
+    A `.Formatter` which attempts to figure out the best format to use for the
+    date, and to make it as compact as possible, but still be complete. This is
+    most useful when used with the `AutoDateLocator`::
+
+    >>> locator = AutoDateLocator()
+    >>> formatter = ConciseDateFormatter(locator)
+
+    Parameters
+    ----------
+    locator : `.ticker.Locator`
+        Locator that this axis is using.
+
+    tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+        Ticks timezone, passed to `.dates.num2date`.
+
+    formats : list of 6 strings, optional
+        Format strings for 6 levels of tick labelling: mostly years,
+        months, days, hours, minutes, and seconds.  Strings use
+        the same format codes as `~datetime.datetime.strftime`.  Default is
+        ``['%Y', '%b', '%d', '%H:%M', '%H:%M', '%S.%f']``
+
+    zero_formats : list of 6 strings, optional
+        Format strings for tick labels that are "zeros" for a given tick
+        level.  For instance, if most ticks are months, ticks around 1 Jan 2005
+        will be labeled "Dec", "2005", "Feb".  The default is
+        ``['', '%Y', '%b', '%b-%d', '%H:%M', '%H:%M']``
+
+    offset_formats : list of 6 strings, optional
+        Format strings for the 6 levels that is applied to the "offset"
+        string found on the right side of an x-axis, or top of a y-axis.
+        Combined with the tick labels this should completely specify the
+        date.  The default is::
+
+            ['', '%Y', '%Y-%b', '%Y-%b-%d', '%Y-%b-%d', '%Y-%b-%d %H:%M']
+
+    show_offset : bool, default: True
+        Whether to show the offset or not.
+
+    usetex : bool, default: :rc:`text.usetex`
+        To enable/disable the use of TeX's math mode for rendering the results
+        of the formatter.
+
+    Examples
+    --------
+    See :doc:`/gallery/ticks/date_concise_formatter`
+
+    .. plot::
+
+        import datetime
+        import matplotlib.dates as mdates
+
+        base = datetime.datetime(2005, 2, 1)
+        dates = np.array([base + datetime.timedelta(hours=(2 * i))
+                          for i in range(732)])
+        N = len(dates)
+        np.random.seed(19680801)
+        y = np.cumsum(np.random.randn(N))
+
+        fig, ax = plt.subplots(constrained_layout=True)
+        locator = mdates.AutoDateLocator()
+        formatter = mdates.ConciseDateFormatter(locator)
+        ax.xaxis.set_major_locator(locator)
+        ax.xaxis.set_major_formatter(formatter)
+
+        ax.plot(dates, y)
+        ax.set_title('Concise Date Formatter')
+
+    """
+
+    def __init__(self, locator, tz=None, formats=None, offset_formats=None,
+                 zero_formats=None, show_offset=True, *, usetex=None):
+        """
+        Autoformat the date labels.  The default format is used to form an
+        initial string, and then redundant elements are removed.
+        """
+        self._locator = locator
+        self._tz = tz
+        self.defaultfmt = '%Y'
+        # there are 6 levels with each level getting a specific format
+        # 0: mostly years,  1: months,  2: days,
+        # 3: hours, 4: minutes, 5: seconds
+        if formats:
+            if len(formats) != 6:
+                raise ValueError('formats argument must be a list of '
+                                 '6 format strings (or None)')
+            self.formats = formats
+        else:
+            self.formats = ['%Y',  # ticks are mostly years
+                            '%b',          # ticks are mostly months
+                            '%d',          # ticks are mostly days
+                            '%H:%M',       # hrs
+                            '%H:%M',       # min
+                            '%S.%f',       # secs
+                            ]
+        # fmt for zeros ticks at this level.  These are
+        # ticks that should be labeled w/ info the level above.
+        # like 1 Jan can just be labelled "Jan".  02:02:00 can
+        # just be labeled 02:02.
+        if zero_formats:
+            if len(zero_formats) != 6:
+                raise ValueError('zero_formats argument must be a list of '
+                                 '6 format strings (or None)')
+            self.zero_formats = zero_formats
+        elif formats:
+            # use the users formats for the zero tick formats
+            self.zero_formats = [''] + self.formats[:-1]
+        else:
+            # make the defaults a bit nicer:
+            self.zero_formats = [''] + self.formats[:-1]
+            self.zero_formats[3] = '%b-%d'
+
+        if offset_formats:
+            if len(offset_formats) != 6:
+                raise ValueError('offset_formats argument must be a list of '
+                                 '6 format strings (or None)')
+            self.offset_formats = offset_formats
+        else:
+            self.offset_formats = ['',
+                                   '%Y',
+                                   '%Y-%b',
+                                   '%Y-%b-%d',
+                                   '%Y-%b-%d',
+                                   '%Y-%b-%d %H:%M']
+        self.offset_string = ''
+        self.show_offset = show_offset
+        self._usetex = mpl._val_or_rc(usetex, 'text.usetex')
+
+    def __call__(self, x, pos=None):
+        formatter = DateFormatter(self.defaultfmt, self._tz,
+                                  usetex=self._usetex)
+        return formatter(x, pos=pos)
+
+    def format_ticks(self, values):
+        tickdatetime = [num2date(value, tz=self._tz) for value in values]
+        tickdate = np.array([tdt.timetuple()[:6] for tdt in tickdatetime])
+
+        # basic algorithm:
+        # 1) only display a part of the date if it changes over the ticks.
+        # 2) don't display the smaller part of the date if:
+        #    it is always the same or if it is the start of the
+        #    year, month, day etc.
+        # fmt for most ticks at this level
+        fmts = self.formats
+        # format beginnings of days, months, years, etc.
+        zerofmts = self.zero_formats
+        # offset fmt are for the offset in the upper left of the
+        # or lower right of the axis.
+        offsetfmts = self.offset_formats
+        show_offset = self.show_offset
+
+        # determine the level we will label at:
+        # mostly 0: years,  1: months,  2: days,
+        # 3: hours, 4: minutes, 5: seconds, 6: microseconds
+        for level in range(5, -1, -1):
+            unique = np.unique(tickdate[:, level])
+            if len(unique) > 1:
+                # if 1 is included in unique, the year is shown in ticks
+                if level < 2 and np.any(unique == 1):
+                    show_offset = False
+                break
+            elif level == 0:
+                # all tickdate are the same, so only micros might be different
+                # set to the most precise (6: microseconds doesn't exist...)
+                level = 5
+
+        # level is the basic level we will label at.
+        # now loop through and decide the actual ticklabels
+        zerovals = [0, 1, 1, 0, 0, 0, 0]
+        labels = [''] * len(tickdate)
+        for nn in range(len(tickdate)):
+            if level < 5:
+                if tickdate[nn][level] == zerovals[level]:
+                    fmt = zerofmts[level]
+                else:
+                    fmt = fmts[level]
+            else:
+                # special handling for seconds + microseconds
+                if (tickdatetime[nn].second == tickdatetime[nn].microsecond
+                        == 0):
+                    fmt = zerofmts[level]
+                else:
+                    fmt = fmts[level]
+            labels[nn] = tickdatetime[nn].strftime(fmt)
+
+        # special handling of seconds and microseconds:
+        # strip extra zeros and decimal if possible.
+        # this is complicated by two factors.  1) we have some level-4 strings
+        # here (i.e. 03:00, '0.50000', '1.000') 2) we would like to have the
+        # same number of decimals for each string (i.e. 0.5 and 1.0).
+        if level >= 5:
+            trailing_zeros = min(
+                (len(s) - len(s.rstrip('0')) for s in labels if '.' in s),
+                default=None)
+            if trailing_zeros:
+                for nn in range(len(labels)):
+                    if '.' in labels[nn]:
+                        labels[nn] = labels[nn][:-trailing_zeros].rstrip('.')
+
+        if show_offset:
+            # set the offset string:
+            if (self._locator.axis and
+                    self._locator.axis.__name__ in ('xaxis', 'yaxis')
+                    and self._locator.axis.get_inverted()):
+                self.offset_string = tickdatetime[0].strftime(offsetfmts[level])
+            else:
+                self.offset_string = tickdatetime[-1].strftime(offsetfmts[level])
+            if self._usetex:
+                self.offset_string = _wrap_in_tex(self.offset_string)
+        else:
+            self.offset_string = ''
+
+        if self._usetex:
+            return [_wrap_in_tex(l) for l in labels]
+        else:
+            return labels
+
+    def get_offset(self):
+        return self.offset_string
+
+    def format_data_short(self, value):
+        return num2date(value, tz=self._tz).strftime('%Y-%m-%d %H:%M:%S')
+
+
+class AutoDateFormatter(ticker.Formatter):
+    """
+    A `.Formatter` which attempts to figure out the best format to use.  This
+    is most useful when used with the `AutoDateLocator`.
+
+    `.AutoDateFormatter` has a ``.scale`` dictionary that maps tick scales (the
+    interval in days between one major tick) to format strings; this dictionary
+    defaults to ::
+
+        self.scaled = {
+            DAYS_PER_YEAR: rcParams['date.autoformatter.year'],
+            DAYS_PER_MONTH: rcParams['date.autoformatter.month'],
+            1: rcParams['date.autoformatter.day'],
+            1 / HOURS_PER_DAY: rcParams['date.autoformatter.hour'],
+            1 / MINUTES_PER_DAY: rcParams['date.autoformatter.minute'],
+            1 / SEC_PER_DAY: rcParams['date.autoformatter.second'],
+            1 / MUSECONDS_PER_DAY: rcParams['date.autoformatter.microsecond'],
+        }
+
+    The formatter uses the format string corresponding to the lowest key in
+    the dictionary that is greater or equal to the current scale.  Dictionary
+    entries can be customized::
+
+        locator = AutoDateLocator()
+        formatter = AutoDateFormatter(locator)
+        formatter.scaled[1/(24*60)] = '%M:%S' # only show min and sec
+
+    Custom callables can also be used instead of format strings.  The following
+    example shows how to use a custom format function to strip trailing zeros
+    from decimal seconds and adds the date to the first ticklabel::
+
+        def my_format_function(x, pos=None):
+            x = matplotlib.dates.num2date(x)
+            if pos == 0:
+                fmt = '%D %H:%M:%S.%f'
+            else:
+                fmt = '%H:%M:%S.%f'
+            label = x.strftime(fmt)
+            label = label.rstrip("0")
+            label = label.rstrip(".")
+            return label
+
+        formatter.scaled[1/(24*60)] = my_format_function
+    """
+
+    # This can be improved by providing some user-level direction on
+    # how to choose the best format (precedence, etc.).
+
+    # Perhaps a 'struct' that has a field for each time-type where a
+    # zero would indicate "don't show" and a number would indicate
+    # "show" with some sort of priority.  Same priorities could mean
+    # show all with the same priority.
+
+    # Or more simply, perhaps just a format string for each
+    # possibility...
+
+    def __init__(self, locator, tz=None, defaultfmt='%Y-%m-%d', *,
+                 usetex=None):
+        """
+        Autoformat the date labels.
+
+        Parameters
+        ----------
+        locator : `.ticker.Locator`
+            Locator that this axis is using.
+
+        tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+            Ticks timezone. If a string, *tz* is passed to `dateutil.tz`.
+
+        defaultfmt : str
+            The default format to use if none of the values in ``self.scaled``
+            are greater than the unit returned by ``locator._get_unit()``.
+
+        usetex : bool, default: :rc:`text.usetex`
+            To enable/disable the use of TeX's math mode for rendering the
+            results of the formatter. If any entries in ``self.scaled`` are set
+            as functions, then it is up to the customized function to enable or
+            disable TeX's math mode itself.
+        """
+        self._locator = locator
+        self._tz = tz
+        self.defaultfmt = defaultfmt
+        self._formatter = DateFormatter(self.defaultfmt, tz)
+        rcParams = mpl.rcParams
+        self._usetex = mpl._val_or_rc(usetex, 'text.usetex')
+        self.scaled = {
+            DAYS_PER_YEAR: rcParams['date.autoformatter.year'],
+            DAYS_PER_MONTH: rcParams['date.autoformatter.month'],
+            1: rcParams['date.autoformatter.day'],
+            1 / HOURS_PER_DAY: rcParams['date.autoformatter.hour'],
+            1 / MINUTES_PER_DAY: rcParams['date.autoformatter.minute'],
+            1 / SEC_PER_DAY: rcParams['date.autoformatter.second'],
+            1 / MUSECONDS_PER_DAY: rcParams['date.autoformatter.microsecond']
+        }
+
+    def _set_locator(self, locator):
+        self._locator = locator
+
+    def __call__(self, x, pos=None):
+        try:
+            locator_unit_scale = float(self._locator._get_unit())
+        except AttributeError:
+            locator_unit_scale = 1
+        # Pick the first scale which is greater than the locator unit.
+        fmt = next((fmt for scale, fmt in sorted(self.scaled.items())
+                    if scale >= locator_unit_scale),
+                   self.defaultfmt)
+
+        if isinstance(fmt, str):
+            self._formatter = DateFormatter(fmt, self._tz, usetex=self._usetex)
+            result = self._formatter(x, pos)
+        elif callable(fmt):
+            result = fmt(x, pos)
+        else:
+            raise TypeError(f'Unexpected type passed to {self!r}.')
+
+        return result
+
+
+class rrulewrapper:
+    """
+    A simple wrapper around a `dateutil.rrule` allowing flexible
+    date tick specifications.
+    """
+    def __init__(self, freq, tzinfo=None, **kwargs):
+        """
+        Parameters
+        ----------
+        freq : {YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY, SECONDLY}
+            Tick frequency. These constants are defined in `dateutil.rrule`,
+            but they are accessible from `matplotlib.dates` as well.
+        tzinfo : `datetime.tzinfo`, optional
+            Time zone information. The default is None.
+        **kwargs
+            Additional keyword arguments are passed to the `dateutil.rrule`.
+        """
+        kwargs['freq'] = freq
+        self._base_tzinfo = tzinfo
+
+        self._update_rrule(**kwargs)
+
+    def set(self, **kwargs):
+        """Set parameters for an existing wrapper."""
+        self._construct.update(kwargs)
+
+        self._update_rrule(**self._construct)
+
+    def _update_rrule(self, **kwargs):
+        tzinfo = self._base_tzinfo
+
+        # rrule does not play nicely with timezones - especially pytz time
+        # zones, it's best to use naive zones and attach timezones once the
+        # datetimes are returned
+        if 'dtstart' in kwargs:
+            dtstart = kwargs['dtstart']
+            if dtstart.tzinfo is not None:
+                if tzinfo is None:
+                    tzinfo = dtstart.tzinfo
+                else:
+                    dtstart = dtstart.astimezone(tzinfo)
+
+                kwargs['dtstart'] = dtstart.replace(tzinfo=None)
+
+        if 'until' in kwargs:
+            until = kwargs['until']
+            if until.tzinfo is not None:
+                if tzinfo is not None:
+                    until = until.astimezone(tzinfo)
+                else:
+                    raise ValueError('until cannot be aware if dtstart '
+                                     'is naive and tzinfo is None')
+
+                kwargs['until'] = until.replace(tzinfo=None)
+
+        self._construct = kwargs.copy()
+        self._tzinfo = tzinfo
+        self._rrule = rrule(**self._construct)
+
+    def _attach_tzinfo(self, dt, tzinfo):
+        # pytz zones are attached by "localizing" the datetime
+        if hasattr(tzinfo, 'localize'):
+            return tzinfo.localize(dt, is_dst=True)
+
+        return dt.replace(tzinfo=tzinfo)
+
+    def _aware_return_wrapper(self, f, returns_list=False):
+        """Decorator function that allows rrule methods to handle tzinfo."""
+        # This is only necessary if we're actually attaching a tzinfo
+        if self._tzinfo is None:
+            return f
+
+        # All datetime arguments must be naive. If they are not naive, they are
+        # converted to the _tzinfo zone before dropping the zone.
+        def normalize_arg(arg):
+            if isinstance(arg, datetime.datetime) and arg.tzinfo is not None:
+                if arg.tzinfo is not self._tzinfo:
+                    arg = arg.astimezone(self._tzinfo)
+
+                return arg.replace(tzinfo=None)
+
+            return arg
+
+        def normalize_args(args, kwargs):
+            args = tuple(normalize_arg(arg) for arg in args)
+            kwargs = {kw: normalize_arg(arg) for kw, arg in kwargs.items()}
+
+            return args, kwargs
+
+        # There are two kinds of functions we care about - ones that return
+        # dates and ones that return lists of dates.
+        if not returns_list:
+            def inner_func(*args, **kwargs):
+                args, kwargs = normalize_args(args, kwargs)
+                dt = f(*args, **kwargs)
+                return self._attach_tzinfo(dt, self._tzinfo)
+        else:
+            def inner_func(*args, **kwargs):
+                args, kwargs = normalize_args(args, kwargs)
+                dts = f(*args, **kwargs)
+                return [self._attach_tzinfo(dt, self._tzinfo) for dt in dts]
+
+        return functools.wraps(f)(inner_func)
+
+    def __getattr__(self, name):
+        if name in self.__dict__:
+            return self.__dict__[name]
+
+        f = getattr(self._rrule, name)
+
+        if name in {'after', 'before'}:
+            return self._aware_return_wrapper(f)
+        elif name in {'xafter', 'xbefore', 'between'}:
+            return self._aware_return_wrapper(f, returns_list=True)
+        else:
+            return f
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+
+
+class DateLocator(ticker.Locator):
+    """
+    Determines the tick locations when plotting dates.
+
+    This class is subclassed by other Locators and
+    is not meant to be used on its own.
+    """
+    hms0d = {'byhour': 0, 'byminute': 0, 'bysecond': 0}
+
+    def __init__(self, tz=None):
+        """
+        Parameters
+        ----------
+        tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+            Ticks timezone. If a string, *tz* is passed to `dateutil.tz`.
+        """
+        self.tz = _get_tzinfo(tz)
+
+    def set_tzinfo(self, tz):
+        """
+        Set timezone info.
+
+        Parameters
+        ----------
+        tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+            Ticks timezone. If a string, *tz* is passed to `dateutil.tz`.
+        """
+        self.tz = _get_tzinfo(tz)
+
+    def datalim_to_dt(self):
+        """Convert axis data interval to datetime objects."""
+        dmin, dmax = self.axis.get_data_interval()
+        if dmin > dmax:
+            dmin, dmax = dmax, dmin
+
+        return num2date(dmin, self.tz), num2date(dmax, self.tz)
+
+    def viewlim_to_dt(self):
+        """Convert the view interval to datetime objects."""
+        vmin, vmax = self.axis.get_view_interval()
+        if vmin > vmax:
+            vmin, vmax = vmax, vmin
+        return num2date(vmin, self.tz), num2date(vmax, self.tz)
+
+    def _get_unit(self):
+        """
+        Return how many days a unit of the locator is; used for
+        intelligent autoscaling.
+        """
+        return 1
+
+    def _get_interval(self):
+        """
+        Return the number of units for each tick.
+        """
+        return 1
+
+    def nonsingular(self, vmin, vmax):
+        """
+        Given the proposed upper and lower extent, adjust the range
+        if it is too close to being singular (i.e. a range of ~0).
+        """
+        if not np.isfinite(vmin) or not np.isfinite(vmax):
+            # Except if there is no data, then use 1970 as default.
+            return (date2num(datetime.date(1970, 1, 1)),
+                    date2num(datetime.date(1970, 1, 2)))
+        if vmax < vmin:
+            vmin, vmax = vmax, vmin
+        unit = self._get_unit()
+        interval = self._get_interval()
+        if abs(vmax - vmin) < 1e-6:
+            vmin -= 2 * unit * interval
+            vmax += 2 * unit * interval
+        return vmin, vmax
+
+
+class RRuleLocator(DateLocator):
+    # use the dateutil rrule instance
+
+    def __init__(self, o, tz=None):
+        super().__init__(tz)
+        self.rule = o
+
+    def __call__(self):
+        # if no data have been set, this will tank with a ValueError
+        try:
+            dmin, dmax = self.viewlim_to_dt()
+        except ValueError:
+            return []
+
+        return self.tick_values(dmin, dmax)
+
+    def tick_values(self, vmin, vmax):
+        start, stop = self._create_rrule(vmin, vmax)
+        dates = self.rule.between(start, stop, True)
+        if len(dates) == 0:
+            return date2num([vmin, vmax])
+        return self.raise_if_exceeds(date2num(dates))
+
+    def _create_rrule(self, vmin, vmax):
+        # set appropriate rrule dtstart and until and return
+        # start and end
+        delta = relativedelta(vmax, vmin)
+
+        # We need to cap at the endpoints of valid datetime
+        try:
+            start = vmin - delta
+        except (ValueError, OverflowError):
+            # cap
+            start = datetime.datetime(1, 1, 1, 0, 0, 0,
+                                      tzinfo=datetime.timezone.utc)
+
+        try:
+            stop = vmax + delta
+        except (ValueError, OverflowError):
+            # cap
+            stop = datetime.datetime(9999, 12, 31, 23, 59, 59,
+                                     tzinfo=datetime.timezone.utc)
+
+        self.rule.set(dtstart=start, until=stop)
+
+        return vmin, vmax
+
+    def _get_unit(self):
+        # docstring inherited
+        freq = self.rule._rrule._freq
+        return self.get_unit_generic(freq)
+
+    @staticmethod
+    def get_unit_generic(freq):
+        if freq == YEARLY:
+            return DAYS_PER_YEAR
+        elif freq == MONTHLY:
+            return DAYS_PER_MONTH
+        elif freq == WEEKLY:
+            return DAYS_PER_WEEK
+        elif freq == DAILY:
+            return 1.0
+        elif freq == HOURLY:
+            return 1.0 / HOURS_PER_DAY
+        elif freq == MINUTELY:
+            return 1.0 / MINUTES_PER_DAY
+        elif freq == SECONDLY:
+            return 1.0 / SEC_PER_DAY
+        else:
+            # error
+            return -1  # or should this just return '1'?
+
+    def _get_interval(self):
+        return self.rule._rrule._interval
+
+
+class AutoDateLocator(DateLocator):
+    """
+    On autoscale, this class picks the best `DateLocator` to set the view
+    limits and the tick locations.
+
+    Attributes
+    ----------
+    intervald : dict
+
+        Mapping of tick frequencies to multiples allowed for that ticking.
+        The default is ::
+
+            self.intervald = {
+                YEARLY  : [1, 2, 4, 5, 10, 20, 40, 50, 100, 200, 400, 500,
+                           1000, 2000, 4000, 5000, 10000],
+                MONTHLY : [1, 2, 3, 4, 6],
+                DAILY   : [1, 2, 3, 7, 14, 21],
+                HOURLY  : [1, 2, 3, 4, 6, 12],
+                MINUTELY: [1, 5, 10, 15, 30],
+                SECONDLY: [1, 5, 10, 15, 30],
+                MICROSECONDLY: [1, 2, 5, 10, 20, 50, 100, 200, 500,
+                                1000, 2000, 5000, 10000, 20000, 50000,
+                                100000, 200000, 500000, 1000000],
+            }
+
+        where the keys are defined in `dateutil.rrule`.
+
+        The interval is used to specify multiples that are appropriate for
+        the frequency of ticking. For instance, every 7 days is sensible
+        for daily ticks, but for minutes/seconds, 15 or 30 make sense.
+
+        When customizing, you should only modify the values for the existing
+        keys. You should not add or delete entries.
+
+        Example for forcing ticks every 3 hours::
+
+            locator = AutoDateLocator()
+            locator.intervald[HOURLY] = [3]  # only show every 3 hours
+    """
+
+    def __init__(self, tz=None, minticks=5, maxticks=None,
+                 interval_multiples=True):
+        """
+        Parameters
+        ----------
+        tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+            Ticks timezone. If a string, *tz* is passed to `dateutil.tz`.
+        minticks : int
+            The minimum number of ticks desired; controls whether ticks occur
+            yearly, monthly, etc.
+        maxticks : int
+            The maximum number of ticks desired; controls the interval between
+            ticks (ticking every other, every 3, etc.).  For fine-grained
+            control, this can be a dictionary mapping individual rrule
+            frequency constants (YEARLY, MONTHLY, etc.) to their own maximum
+            number of ticks.  This can be used to keep the number of ticks
+            appropriate to the format chosen in `AutoDateFormatter`. Any
+            frequency not specified in this dictionary is given a default
+            value.
+        interval_multiples : bool, default: True
+            Whether ticks should be chosen to be multiple of the interval,
+            locking them to 'nicer' locations.  For example, this will force
+            the ticks to be at hours 0, 6, 12, 18 when hourly ticking is done
+            at 6 hour intervals.
+        """
+        super().__init__(tz=tz)
+        self._freq = YEARLY
+        self._freqs = [YEARLY, MONTHLY, DAILY, HOURLY, MINUTELY,
+                       SECONDLY, MICROSECONDLY]
+        self.minticks = minticks
+
+        self.maxticks = {YEARLY: 11, MONTHLY: 12, DAILY: 11, HOURLY: 12,
+                         MINUTELY: 11, SECONDLY: 11, MICROSECONDLY: 8}
+        if maxticks is not None:
+            try:
+                self.maxticks.update(maxticks)
+            except TypeError:
+                # Assume we were given an integer. Use this as the maximum
+                # number of ticks for every frequency and create a
+                # dictionary for this
+                self.maxticks = dict.fromkeys(self._freqs, maxticks)
+        self.interval_multiples = interval_multiples
+        self.intervald = {
+            YEARLY:   [1, 2, 4, 5, 10, 20, 40, 50, 100, 200, 400, 500,
+                       1000, 2000, 4000, 5000, 10000],
+            MONTHLY:  [1, 2, 3, 4, 6],
+            DAILY:    [1, 2, 3, 7, 14, 21],
+            HOURLY:   [1, 2, 3, 4, 6, 12],
+            MINUTELY: [1, 5, 10, 15, 30],
+            SECONDLY: [1, 5, 10, 15, 30],
+            MICROSECONDLY: [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000,
+                            5000, 10000, 20000, 50000, 100000, 200000, 500000,
+                            1000000],
+                            }
+        if interval_multiples:
+            # Swap "3" for "4" in the DAILY list; If we use 3 we get bad
+            # tick loc for months w/ 31 days: 1, 4, ..., 28, 31, 1
+            # If we use 4 then we get: 1, 5, ... 25, 29, 1
+            self.intervald[DAILY] = [1, 2, 4, 7, 14]
+
+        self._byranges = [None, range(1, 13), range(1, 32),
+                          range(0, 24), range(0, 60), range(0, 60), None]
+
+    def __call__(self):
+        # docstring inherited
+        dmin, dmax = self.viewlim_to_dt()
+        locator = self.get_locator(dmin, dmax)
+        return locator()
+
+    def tick_values(self, vmin, vmax):
+        return self.get_locator(vmin, vmax).tick_values(vmin, vmax)
+
+    def nonsingular(self, vmin, vmax):
+        # whatever is thrown at us, we can scale the unit.
+        # But default nonsingular date plots at an ~4 year period.
+        if not np.isfinite(vmin) or not np.isfinite(vmax):
+            # Except if there is no data, then use 1970 as default.
+            return (date2num(datetime.date(1970, 1, 1)),
+                    date2num(datetime.date(1970, 1, 2)))
+        if vmax < vmin:
+            vmin, vmax = vmax, vmin
+        if vmin == vmax:
+            vmin = vmin - DAYS_PER_YEAR * 2
+            vmax = vmax + DAYS_PER_YEAR * 2
+        return vmin, vmax
+
+    def _get_unit(self):
+        if self._freq in [MICROSECONDLY]:
+            return 1. / MUSECONDS_PER_DAY
+        else:
+            return RRuleLocator.get_unit_generic(self._freq)
+
+    def get_locator(self, dmin, dmax):
+        """Pick the best locator based on a distance."""
+        delta = relativedelta(dmax, dmin)
+        tdelta = dmax - dmin
+
+        # take absolute difference
+        if dmin > dmax:
+            delta = -delta
+            tdelta = -tdelta
+        # The following uses a mix of calls to relativedelta and timedelta
+        # methods because there is incomplete overlap in the functionality of
+        # these similar functions, and it's best to avoid doing our own math
+        # whenever possible.
+        numYears = float(delta.years)
+        numMonths = numYears * MONTHS_PER_YEAR + delta.months
+        numDays = tdelta.days  # Avoids estimates of days/month, days/year.
+        numHours = numDays * HOURS_PER_DAY + delta.hours
+        numMinutes = numHours * MIN_PER_HOUR + delta.minutes
+        numSeconds = np.floor(tdelta.total_seconds())
+        numMicroseconds = np.floor(tdelta.total_seconds() * 1e6)
+
+        nums = [numYears, numMonths, numDays, numHours, numMinutes,
+                numSeconds, numMicroseconds]
+
+        use_rrule_locator = [True] * 6 + [False]
+
+        # Default setting of bymonth, etc. to pass to rrule
+        # [unused (for year), bymonth, bymonthday, byhour, byminute,
+        #  bysecond, unused (for microseconds)]
+        byranges = [None, 1, 1, 0, 0, 0, None]
+
+        # Loop over all the frequencies and try to find one that gives at
+        # least a minticks tick positions.  Once this is found, look for
+        # an interval from a list specific to that frequency that gives no
+        # more than maxticks tick positions. Also, set up some ranges
+        # (bymonth, etc.) as appropriate to be passed to rrulewrapper.
+        for i, (freq, num) in enumerate(zip(self._freqs, nums)):
+            # If this particular frequency doesn't give enough ticks, continue
+            if num < self.minticks:
+                # Since we're not using this particular frequency, set
+                # the corresponding by_ to None so the rrule can act as
+                # appropriate
+                byranges[i] = None
+                continue
+
+            # Find the first available interval that doesn't give too many
+            # ticks
+            for interval in self.intervald[freq]:
+                if num <= interval * (self.maxticks[freq] - 1):
+                    break
+            else:
+                if not (self.interval_multiples and freq == DAILY):
+                    _api.warn_external(
+                        f"AutoDateLocator was unable to pick an appropriate "
+                        f"interval for this date range. It may be necessary "
+                        f"to add an interval value to the AutoDateLocator's "
+                        f"intervald dictionary. Defaulting to {interval}.")
+
+            # Set some parameters as appropriate
+            self._freq = freq
+
+            if self._byranges[i] and self.interval_multiples:
+                byranges[i] = self._byranges[i][::interval]
+                if i in (DAILY, WEEKLY):
+                    if interval == 14:
+                        # just make first and 15th.  Avoids 30th.
+                        byranges[i] = [1, 15]
+                    elif interval == 7:
+                        byranges[i] = [1, 8, 15, 22]
+
+                interval = 1
+            else:
+                byranges[i] = self._byranges[i]
+            break
+        else:
+            interval = 1
+
+        if (freq == YEARLY) and self.interval_multiples:
+            locator = YearLocator(interval, tz=self.tz)
+        elif use_rrule_locator[i]:
+            _, bymonth, bymonthday, byhour, byminute, bysecond, _ = byranges
+            rrule = rrulewrapper(self._freq, interval=interval,
+                                 dtstart=dmin, until=dmax,
+                                 bymonth=bymonth, bymonthday=bymonthday,
+                                 byhour=byhour, byminute=byminute,
+                                 bysecond=bysecond)
+
+            locator = RRuleLocator(rrule, tz=self.tz)
+        else:
+            locator = MicrosecondLocator(interval, tz=self.tz)
+            if date2num(dmin) > 70 * 365 and interval < 1000:
+                _api.warn_external(
+                    'Plotting microsecond time intervals for dates far from '
+                    f'the epoch (time origin: {get_epoch()}) is not well-'
+                    'supported. See matplotlib.dates.set_epoch to change the '
+                    'epoch.')
+
+        locator.set_axis(self.axis)
+        return locator
+
+
+class YearLocator(RRuleLocator):
+    """
+    Make ticks on a given day of each year that is a multiple of base.
+
+    Examples::
+
+      # Tick every year on Jan 1st
+      locator = YearLocator()
+
+      # Tick every 5 years on July 4th
+      locator = YearLocator(5, month=7, day=4)
+    """
+    def __init__(self, base=1, month=1, day=1, tz=None):
+        """
+        Parameters
+        ----------
+        base : int, default: 1
+            Mark ticks every *base* years.
+        month : int, default: 1
+            The month on which to place the ticks, starting from 1. Default is
+            January.
+        day : int, default: 1
+            The day on which to place the ticks.
+        tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+            Ticks timezone. If a string, *tz* is passed to `dateutil.tz`.
+        """
+        rule = rrulewrapper(YEARLY, interval=base, bymonth=month,
+                            bymonthday=day, **self.hms0d)
+        super().__init__(rule, tz=tz)
+        self.base = ticker._Edge_integer(base, 0)
+
+    def _create_rrule(self, vmin, vmax):
+        # 'start' needs to be a multiple of the interval to create ticks on
+        # interval multiples when the tick frequency is YEARLY
+        ymin = max(self.base.le(vmin.year) * self.base.step, 1)
+        ymax = min(self.base.ge(vmax.year) * self.base.step, 9999)
+
+        c = self.rule._construct
+        replace = {'year': ymin,
+                   'month': c.get('bymonth', 1),
+                   'day': c.get('bymonthday', 1),
+                   'hour': 0, 'minute': 0, 'second': 0}
+
+        start = vmin.replace(**replace)
+        stop = start.replace(year=ymax)
+        self.rule.set(dtstart=start, until=stop)
+
+        return start, stop
+
+
+class MonthLocator(RRuleLocator):
+    """
+    Make ticks on occurrences of each month, e.g., 1, 3, 12.
+    """
+    def __init__(self, bymonth=None, bymonthday=1, interval=1, tz=None):
+        """
+        Parameters
+        ----------
+        bymonth : int or list of int, default: all months
+            Ticks will be placed on every month in *bymonth*. Default is
+            ``range(1, 13)``, i.e. every month.
+        bymonthday : int, default: 1
+            The day on which to place the ticks.
+        interval : int, default: 1
+            The interval between each iteration. For example, if
+            ``interval=2``, mark every second occurrence.
+        tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+            Ticks timezone. If a string, *tz* is passed to `dateutil.tz`.
+        """
+        if bymonth is None:
+            bymonth = range(1, 13)
+
+        rule = rrulewrapper(MONTHLY, bymonth=bymonth, bymonthday=bymonthday,
+                            interval=interval, **self.hms0d)
+        super().__init__(rule, tz=tz)
+
+
+class WeekdayLocator(RRuleLocator):
+    """
+    Make ticks on occurrences of each weekday.
+    """
+
+    def __init__(self, byweekday=1, interval=1, tz=None):
+        """
+        Parameters
+        ----------
+        byweekday : int or list of int, default: all days
+            Ticks will be placed on every weekday in *byweekday*. Default is
+            every day.
+
+            Elements of *byweekday* must be one of MO, TU, WE, TH, FR, SA,
+            SU, the constants from :mod:`dateutil.rrule`, which have been
+            imported into the :mod:`matplotlib.dates` namespace.
+        interval : int, default: 1
+            The interval between each iteration. For example, if
+            ``interval=2``, mark every second occurrence.
+        tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+            Ticks timezone. If a string, *tz* is passed to `dateutil.tz`.
+        """
+        rule = rrulewrapper(DAILY, byweekday=byweekday,
+                            interval=interval, **self.hms0d)
+        super().__init__(rule, tz=tz)
+
+
+class DayLocator(RRuleLocator):
+    """
+    Make ticks on occurrences of each day of the month.  For example,
+    1, 15, 30.
+    """
+    def __init__(self, bymonthday=None, interval=1, tz=None):
+        """
+        Parameters
+        ----------
+        bymonthday : int or list of int, default: all days
+            Ticks will be placed on every day in *bymonthday*. Default is
+            ``bymonthday=range(1, 32)``, i.e., every day of the month.
+        interval : int, default: 1
+            The interval between each iteration. For example, if
+            ``interval=2``, mark every second occurrence.
+        tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+            Ticks timezone. If a string, *tz* is passed to `dateutil.tz`.
+        """
+        if interval != int(interval) or interval < 1:
+            raise ValueError("interval must be an integer greater than 0")
+        if bymonthday is None:
+            bymonthday = range(1, 32)
+
+        rule = rrulewrapper(DAILY, bymonthday=bymonthday,
+                            interval=interval, **self.hms0d)
+        super().__init__(rule, tz=tz)
+
+
+class HourLocator(RRuleLocator):
+    """
+    Make ticks on occurrences of each hour.
+    """
+    def __init__(self, byhour=None, interval=1, tz=None):
+        """
+        Parameters
+        ----------
+        byhour : int or list of int, default: all hours
+            Ticks will be placed on every hour in *byhour*. Default is
+            ``byhour=range(24)``, i.e., every hour.
+        interval : int, default: 1
+            The interval between each iteration. For example, if
+            ``interval=2``, mark every second occurrence.
+        tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+            Ticks timezone. If a string, *tz* is passed to `dateutil.tz`.
+        """
+        if byhour is None:
+            byhour = range(24)
+
+        rule = rrulewrapper(HOURLY, byhour=byhour, interval=interval,
+                            byminute=0, bysecond=0)
+        super().__init__(rule, tz=tz)
+
+
+class MinuteLocator(RRuleLocator):
+    """
+    Make ticks on occurrences of each minute.
+    """
+    def __init__(self, byminute=None, interval=1, tz=None):
+        """
+        Parameters
+        ----------
+        byminute : int or list of int, default: all minutes
+            Ticks will be placed on every minute in *byminute*. Default is
+            ``byminute=range(60)``, i.e., every minute.
+        interval : int, default: 1
+            The interval between each iteration. For example, if
+            ``interval=2``, mark every second occurrence.
+        tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+            Ticks timezone. If a string, *tz* is passed to `dateutil.tz`.
+        """
+        if byminute is None:
+            byminute = range(60)
+
+        rule = rrulewrapper(MINUTELY, byminute=byminute, interval=interval,
+                            bysecond=0)
+        super().__init__(rule, tz=tz)
+
+
+class SecondLocator(RRuleLocator):
+    """
+    Make ticks on occurrences of each second.
+    """
+    def __init__(self, bysecond=None, interval=1, tz=None):
+        """
+        Parameters
+        ----------
+        bysecond : int or list of int, default: all seconds
+            Ticks will be placed on every second in *bysecond*. Default is
+            ``bysecond = range(60)``, i.e., every second.
+        interval : int, default: 1
+            The interval between each iteration. For example, if
+            ``interval=2``, mark every second occurrence.
+        tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+            Ticks timezone. If a string, *tz* is passed to `dateutil.tz`.
+        """
+        if bysecond is None:
+            bysecond = range(60)
+
+        rule = rrulewrapper(SECONDLY, bysecond=bysecond, interval=interval)
+        super().__init__(rule, tz=tz)
+
+
+class MicrosecondLocator(DateLocator):
+    """
+    Make ticks on regular intervals of one or more microsecond(s).
+
+    .. note::
+
+        By default, Matplotlib uses a floating point representation of time in
+        days since the epoch, so plotting data with
+        microsecond time resolution does not work well for
+        dates that are far (about 70 years) from the epoch (check with
+        `~.dates.get_epoch`).
+
+        If you want sub-microsecond resolution time plots, it is strongly
+        recommended to use floating point seconds, not datetime-like
+        time representation.
+
+        If you really must use datetime.datetime() or similar and still
+        need microsecond precision, change the time origin via
+        `.dates.set_epoch` to something closer to the dates being plotted.
+        See :doc:`/gallery/ticks/date_precision_and_epochs`.
+
+    """
+    def __init__(self, interval=1, tz=None):
+        """
+        Parameters
+        ----------
+        interval : int, default: 1
+            The interval between each iteration. For example, if
+            ``interval=2``, mark every second occurrence.
+        tz : str or `~datetime.tzinfo`, default: :rc:`timezone`
+            Ticks timezone. If a string, *tz* is passed to `dateutil.tz`.
+        """
+        super().__init__(tz=tz)
+        self._interval = interval
+        self._wrapped_locator = ticker.MultipleLocator(interval)
+
+    def set_axis(self, axis):
+        self._wrapped_locator.set_axis(axis)
+        return super().set_axis(axis)
+
+    def __call__(self):
+        # if no data have been set, this will tank with a ValueError
+        try:
+            dmin, dmax = self.viewlim_to_dt()
+        except ValueError:
+            return []
+
+        return self.tick_values(dmin, dmax)
+
+    def tick_values(self, vmin, vmax):
+        nmin, nmax = date2num((vmin, vmax))
+        t0 = np.floor(nmin)
+        nmax = nmax - t0
+        nmin = nmin - t0
+        nmin *= MUSECONDS_PER_DAY
+        nmax *= MUSECONDS_PER_DAY
+
+        ticks = self._wrapped_locator.tick_values(nmin, nmax)
+
+        ticks = ticks / MUSECONDS_PER_DAY + t0
+        return ticks
+
+    def _get_unit(self):
+        # docstring inherited
+        return 1. / MUSECONDS_PER_DAY
+
+    def _get_interval(self):
+        # docstring inherited
+        return self._interval
+
+
+class DateConverter(units.ConversionInterface):
+    """
+    Converter for `datetime.date` and `datetime.datetime` data, or for
+    date/time data represented as it would be converted by `date2num`.
+
+    The 'unit' tag for such data is None or a `~datetime.tzinfo` instance.
+    """
+
+    def __init__(self, *, interval_multiples=True):
+        self._interval_multiples = interval_multiples
+        super().__init__()
+
+    def axisinfo(self, unit, axis):
+        """
+        Return the `~matplotlib.units.AxisInfo` for *unit*.
+
+        *unit* is a `~datetime.tzinfo` instance or None.
+        The *axis* argument is required but not used.
+        """
+        tz = unit
+
+        majloc = AutoDateLocator(tz=tz,
+                                 interval_multiples=self._interval_multiples)
+        majfmt = AutoDateFormatter(majloc, tz=tz)
+        datemin = datetime.date(1970, 1, 1)
+        datemax = datetime.date(1970, 1, 2)
+
+        return units.AxisInfo(majloc=majloc, majfmt=majfmt, label='',
+                              default_limits=(datemin, datemax))
+
+    @staticmethod
+    def convert(value, unit, axis):
+        """
+        If *value* is not already a number or sequence of numbers, convert it
+        with `date2num`.
+
+        The *unit* and *axis* arguments are not used.
+        """
+        return date2num(value)
+
+    @staticmethod
+    def default_units(x, axis):
+        """
+        Return the `~datetime.tzinfo` instance of *x* or of its first element,
+        or None
+        """
+        if isinstance(x, np.ndarray):
+            x = x.ravel()
+
+        try:
+            x = cbook._safe_first_finite(x)
+        except (TypeError, StopIteration):
+            pass
+
+        try:
+            return x.tzinfo
+        except AttributeError:
+            pass
+        return None
+
+
+class ConciseDateConverter(DateConverter):
+    # docstring inherited
+
+    def __init__(self, formats=None, zero_formats=None, offset_formats=None,
+                 show_offset=True, *, interval_multiples=True):
+        self._formats = formats
+        self._zero_formats = zero_formats
+        self._offset_formats = offset_formats
+        self._show_offset = show_offset
+        self._interval_multiples = interval_multiples
+        super().__init__()
+
+    def axisinfo(self, unit, axis):
+        # docstring inherited
+        tz = unit
+        majloc = AutoDateLocator(tz=tz,
+                                 interval_multiples=self._interval_multiples)
+        majfmt = ConciseDateFormatter(majloc, tz=tz, formats=self._formats,
+                                      zero_formats=self._zero_formats,
+                                      offset_formats=self._offset_formats,
+                                      show_offset=self._show_offset)
+        datemin = datetime.date(1970, 1, 1)
+        datemax = datetime.date(1970, 1, 2)
+        return units.AxisInfo(majloc=majloc, majfmt=majfmt, label='',
+                              default_limits=(datemin, datemax))
+
+
+class _SwitchableDateConverter:
+    """
+    Helper converter-like object that generates and dispatches to
+    temporary ConciseDateConverter or DateConverter instances based on
+    :rc:`date.converter` and :rc:`date.interval_multiples`.
+    """
+
+    @staticmethod
+    def _get_converter():
+        converter_cls = {
+            "concise": ConciseDateConverter, "auto": DateConverter}[
+                mpl.rcParams["date.converter"]]
+        interval_multiples = mpl.rcParams["date.interval_multiples"]
+        return converter_cls(interval_multiples=interval_multiples)
+
+    def axisinfo(self, *args, **kwargs):
+        return self._get_converter().axisinfo(*args, **kwargs)
+
+    def default_units(self, *args, **kwargs):
+        return self._get_converter().default_units(*args, **kwargs)
+
+    def convert(self, *args, **kwargs):
+        return self._get_converter().convert(*args, **kwargs)
+
+
+units.registry[np.datetime64] = \
+    units.registry[datetime.date] = \
+    units.registry[datetime.datetime] = \
+    _SwitchableDateConverter()

outputs/audit_venv/lib/python3.11/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")

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/dviread.pyi

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

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/figure.pyi

@@ -0,0 +1,428 @@
+from collections.abc import Callable, Hashable, Iterable, Sequence
+import os
+from typing import Any, IO, Literal, TypeVar, overload
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+from matplotlib.artist import Artist
+from matplotlib.axes import Axes
+from matplotlib.backend_bases import (
+    FigureCanvasBase,
+    MouseButton,
+    MouseEvent,
+    RendererBase,
+)
+from matplotlib.colors import Colormap, Normalize
+from matplotlib.colorbar import Colorbar
+from matplotlib.colorizer import ColorizingArtist, Colorizer
+from matplotlib.cm import ScalarMappable
+from matplotlib.gridspec import GridSpec, SubplotSpec, SubplotParams as SubplotParams
+from matplotlib.image import _ImageBase, FigureImage
+from matplotlib.layout_engine import LayoutEngine
+from matplotlib.legend import Legend
+from matplotlib.lines import Line2D
+from matplotlib.patches import Rectangle, Patch
+from matplotlib.text import Text
+from matplotlib.transforms import Affine2D, Bbox, BboxBase, Transform
+from mpl_toolkits.mplot3d import Axes3D
+
+from .typing import ColorType, HashableList
+
+_T = TypeVar("_T")
+
+class FigureBase(Artist):
+    artists: list[Artist]
+    lines: list[Line2D]
+    patches: list[Patch]
+    texts: list[Text]
+    images: list[_ImageBase]
+    legends: list[Legend]
+    subfigs: list[SubFigure]
+    stale: bool
+    suppressComposite: bool | None
+    def __init__(self, **kwargs) -> None: ...
+    def autofmt_xdate(
+        self,
+        bottom: float = ...,
+        rotation: int = ...,
+        ha: Literal["left", "center", "right"] = ...,
+        which: Literal["major", "minor", "both"] = ...,
+    ) -> None: ...
+    def get_children(self) -> list[Artist]: ...
+    def contains(self, mouseevent: MouseEvent) -> tuple[bool, dict[Any, Any]]: ...
+    def suptitle(self, t: str, **kwargs) -> Text: ...
+    def get_suptitle(self) -> str: ...
+    def supxlabel(self, t: str, **kwargs) -> Text: ...
+    def get_supxlabel(self) -> str: ...
+    def supylabel(self, t: str, **kwargs) -> Text: ...
+    def get_supylabel(self) -> str: ...
+    def get_edgecolor(self) -> ColorType: ...
+    def get_facecolor(self) -> ColorType: ...
+    def get_frameon(self) -> bool: ...
+    def set_linewidth(self, linewidth: float) -> None: ...
+    def get_linewidth(self) -> float: ...
+    def set_edgecolor(self, color: ColorType) -> None: ...
+    def set_facecolor(self, color: ColorType) -> None: ...
+    @overload
+    def get_figure(self, root: Literal[True]) -> Figure: ...
+    @overload
+    def get_figure(self, root: Literal[False]) -> Figure | SubFigure: ...
+    @overload
+    def get_figure(self, root: bool = ...) -> Figure | SubFigure: ...
+    def set_frameon(self, b: bool) -> None: ...
+    @property
+    def frameon(self) -> bool: ...
+    @frameon.setter
+    def frameon(self, b: bool) -> None: ...
+    def add_artist(self, artist: Artist, clip: bool = ...) -> Artist: ...
+    @overload
+    def add_axes(self, ax: Axes) -> Axes: ...
+    @overload
+    def add_axes(
+        self,
+        rect: tuple[float, float, float, float],
+        projection: None | str = ...,
+        polar: bool = ...,
+        **kwargs
+    ) -> Axes: ...
+
+    # TODO: docstring indicates SubplotSpec a valid arg, but none of the listed signatures appear to be that
+    @overload
+    def add_subplot(self, *args: Any, projection: Literal["3d"], **kwargs: Any) -> Axes3D: ...
+    @overload
+    def add_subplot(
+        self, nrows: int, ncols: int, index: int | tuple[int, int], **kwargs: Any
+    ) -> Axes: ...
+    @overload
+    def add_subplot(self, pos: int, **kwargs: Any) -> Axes: ...
+    @overload
+    def add_subplot(self, ax: Axes, **kwargs: Any) -> Axes: ...
+    @overload
+    def add_subplot(self, ax: SubplotSpec, **kwargs: Any) -> Axes: ...
+    @overload
+    def add_subplot(self, **kwargs: Any) -> Axes: ...
+
+    @overload
+    def subplots(
+        self,
+        nrows: Literal[1] = ...,
+        ncols: Literal[1] = ...,
+        *,
+        sharex: bool | Literal["none", "all", "row", "col"] = ...,
+        sharey: bool | Literal["none", "all", "row", "col"] = ...,
+        squeeze: Literal[True] = ...,
+        width_ratios: Sequence[float] | None = ...,
+        height_ratios: Sequence[float] | None = ...,
+        subplot_kw: dict[str, Any] | None = ...,
+        gridspec_kw: dict[str, Any] | None = ...,
+    ) -> Axes: ...
+    @overload
+    def subplots(
+        self,
+        nrows: int = ...,
+        ncols: int = ...,
+        *,
+        sharex: bool | Literal["none", "all", "row", "col"] = ...,
+        sharey: bool | Literal["none", "all", "row", "col"] = ...,
+        squeeze: Literal[False],
+        width_ratios: Sequence[float] | None = ...,
+        height_ratios: Sequence[float] | None = ...,
+        subplot_kw: dict[str, Any] | None = ...,
+        gridspec_kw: dict[str, Any] | None = ...,
+    ) -> np.ndarray: ...  # TODO numpy/numpy#24738
+    @overload
+    def subplots(
+        self,
+        nrows: int = ...,
+        ncols: int = ...,
+        *,
+        sharex: bool | Literal["none", "all", "row", "col"] = ...,
+        sharey: bool | Literal["none", "all", "row", "col"] = ...,
+        squeeze: bool = ...,
+        width_ratios: Sequence[float] | None = ...,
+        height_ratios: Sequence[float] | None = ...,
+        subplot_kw: dict[str, Any] | None = ...,
+        gridspec_kw: dict[str, Any] | None = ...,
+    ) -> Any: ...
+    def delaxes(self, ax: Axes) -> None: ...
+    def clear(self, keep_observers: bool = ...) -> None: ...
+    def clf(self, keep_observers: bool = ...) -> None: ...
+
+    @overload
+    def legend(self) -> Legend: ...
+    @overload
+    def legend(self, handles: Iterable[Artist], labels: Iterable[str], **kwargs) -> Legend: ...
+    @overload
+    def legend(self, *, handles: Iterable[Artist], **kwargs) -> Legend: ...
+    @overload
+    def legend(self, labels: Iterable[str], **kwargs) -> Legend: ...
+    @overload
+    def legend(self, **kwargs) -> Legend: ...
+
+    def text(
+        self,
+        x: float,
+        y: float,
+        s: str,
+        fontdict: dict[str, Any] | None = ...,
+        **kwargs
+    ) -> Text: ...
+    def colorbar(
+        self,
+        mappable: ScalarMappable | ColorizingArtist,
+        cax: Axes | None = ...,
+        ax: Axes | Iterable[Axes] | None = ...,
+        use_gridspec: bool = ...,
+        **kwargs
+    ) -> Colorbar: ...
+    def subplots_adjust(
+        self,
+        left: float | None = ...,
+        bottom: float | None = ...,
+        right: float | None = ...,
+        top: float | None = ...,
+        wspace: float | None = ...,
+        hspace: float | None = ...,
+    ) -> None: ...
+    def align_xlabels(self, axs: Iterable[Axes] | None = ...) -> None: ...
+    def align_ylabels(self, axs: Iterable[Axes] | None = ...) -> None: ...
+    def align_titles(self, axs: Iterable[Axes] | None = ...) -> None: ...
+    def align_labels(self, axs: Iterable[Axes] | None = ...) -> None: ...
+    def add_gridspec(self, nrows: int = ..., ncols: int = ..., **kwargs) -> GridSpec: ...
+    @overload
+    def subfigures(
+        self,
+        nrows: int = ...,
+        ncols: int = ...,
+        squeeze: Literal[False] = ...,
+        wspace: float | None = ...,
+        hspace: float | None = ...,
+        width_ratios: ArrayLike | None = ...,
+        height_ratios: ArrayLike | None = ...,
+        **kwargs
+    ) -> np.ndarray: ...
+    @overload
+    def subfigures(
+        self,
+        nrows: int = ...,
+        ncols: int = ...,
+        squeeze: Literal[True] = ...,
+        wspace: float | None = ...,
+        hspace: float | None = ...,
+        width_ratios: ArrayLike | None = ...,
+        height_ratios: ArrayLike | None = ...,
+        **kwargs
+    ) -> np.ndarray | SubFigure: ...
+    def add_subfigure(self, subplotspec: SubplotSpec, **kwargs) -> SubFigure: ...
+    def sca(self, a: Axes) -> Axes: ...
+    def gca(self) -> Axes: ...
+    def _gci(self) -> ColorizingArtist | None: ...
+    def _process_projection_requirements(
+        self, *, axes_class=None, polar=False, projection=None, **kwargs
+    ) -> tuple[type[Axes], dict[str, Any]]: ...
+    def get_default_bbox_extra_artists(self) -> list[Artist]: ...
+    def get_tightbbox(
+        self,
+        renderer: RendererBase | None = ...,
+        *,
+        bbox_extra_artists: Iterable[Artist] | None = ...,
+    ) -> Bbox: ...
+    @overload
+    def subplot_mosaic(
+        self,
+        mosaic: str,
+        *,
+        sharex: bool = ...,
+        sharey: bool = ...,
+        width_ratios: ArrayLike | None = ...,
+        height_ratios: ArrayLike | None = ...,
+        empty_sentinel: str = ...,
+        subplot_kw: dict[str, Any] | None = ...,
+        per_subplot_kw: dict[str | tuple[str, ...], dict[str, Any]] | None = ...,
+        gridspec_kw: dict[str, Any] | None = ...,
+    ) -> dict[str, Axes]: ...
+    @overload
+    def subplot_mosaic(
+        self,
+        mosaic: list[HashableList[_T]],
+        *,
+        sharex: bool = ...,
+        sharey: bool = ...,
+        width_ratios: ArrayLike | None = ...,
+        height_ratios: ArrayLike | None = ...,
+        empty_sentinel: _T = ...,
+        subplot_kw: dict[str, Any] | None = ...,
+        per_subplot_kw: dict[_T | tuple[_T, ...], dict[str, Any]] | None = ...,
+        gridspec_kw: dict[str, Any] | None = ...,
+    ) -> dict[_T, Axes]: ...
+    @overload
+    def subplot_mosaic(
+        self,
+        mosaic: list[HashableList[Hashable]],
+        *,
+        sharex: bool = ...,
+        sharey: bool = ...,
+        width_ratios: ArrayLike | None = ...,
+        height_ratios: ArrayLike | None = ...,
+        empty_sentinel: Any = ...,
+        subplot_kw: dict[str, Any] | None = ...,
+        per_subplot_kw: dict[Hashable | tuple[Hashable, ...], dict[str, Any]] | None = ...,
+        gridspec_kw: dict[str, Any] | None = ...,
+    ) -> dict[Hashable, Axes]: ...
+
+class SubFigure(FigureBase):
+    @property
+    def figure(self) -> Figure: ...
+    subplotpars: SubplotParams
+    dpi_scale_trans: Affine2D
+    transFigure: Transform
+    bbox_relative: Bbox
+    figbbox: BboxBase
+    bbox: BboxBase
+    transSubfigure: Transform
+    patch: Rectangle
+    def __init__(
+        self,
+        parent: Figure | SubFigure,
+        subplotspec: SubplotSpec,
+        *,
+        facecolor: ColorType | None = ...,
+        edgecolor: ColorType | None = ...,
+        linewidth: float = ...,
+        frameon: bool | None = ...,
+        **kwargs
+    ) -> None: ...
+    @property
+    def canvas(self) -> FigureCanvasBase: ...
+    @property
+    def dpi(self) -> float: ...
+    @dpi.setter
+    def dpi(self, value: float) -> None: ...
+    def get_dpi(self) -> float: ...
+    def set_dpi(self, val) -> None: ...
+    def get_constrained_layout(self) -> bool: ...
+    def get_constrained_layout_pads(
+        self, relative: bool = ...
+    ) -> tuple[float, float, float, float]: ...
+    def get_layout_engine(self) -> LayoutEngine: ...
+    @property  # type: ignore[misc]
+    def axes(self) -> list[Axes]: ...  # type: ignore[override]
+    def get_axes(self) -> list[Axes]: ...
+
+class Figure(FigureBase):
+    @property
+    def figure(self) -> Figure: ...
+    bbox_inches: Bbox
+    dpi_scale_trans: Affine2D
+    bbox: BboxBase
+    figbbox: BboxBase
+    transFigure: Transform
+    transSubfigure: Transform
+    patch: Rectangle
+    subplotpars: SubplotParams
+    def __init__(
+        self,
+        figsize: tuple[float, float] | None = ...,
+        dpi: float | None = ...,
+        *,
+        facecolor: ColorType | None = ...,
+        edgecolor: ColorType | None = ...,
+        linewidth: float = ...,
+        frameon: bool | None = ...,
+        subplotpars: SubplotParams | None = ...,
+        tight_layout: bool | dict[str, Any] | None = ...,
+        constrained_layout: bool | dict[str, Any] | None = ...,
+        layout: Literal["constrained", "compressed", "tight"]
+        | LayoutEngine
+        | None = ...,
+        **kwargs
+    ) -> None: ...
+    def pick(self, mouseevent: MouseEvent) -> None: ...
+    def set_layout_engine(
+        self,
+        layout: Literal["constrained", "compressed", "tight", "none"]
+        | LayoutEngine
+        | None = ...,
+        **kwargs
+    ) -> None: ...
+    def get_layout_engine(self) -> LayoutEngine | None: ...
+    def _repr_html_(self) -> str | None: ...
+    def show(self, warn: bool = ...) -> None: ...
+    @property
+    def number(self) -> int | str: ...
+    @number.setter
+    def number(self, num: int | str) -> None: ...
+    @property  # type: ignore[misc]
+    def axes(self) -> list[Axes]: ...  # type: ignore[override]
+    def get_axes(self) -> list[Axes]: ...
+    @property
+    def dpi(self) -> float: ...
+    @dpi.setter
+    def dpi(self, dpi: float) -> None: ...
+    def get_tight_layout(self) -> bool: ...
+    def get_constrained_layout_pads(
+        self, relative: bool = ...
+    ) -> tuple[float, float, float, float]: ...
+    def get_constrained_layout(self) -> bool: ...
+    canvas: FigureCanvasBase
+    def set_canvas(self, canvas: FigureCanvasBase) -> None: ...
+    def figimage(
+        self,
+        X: ArrayLike,
+        xo: int = ...,
+        yo: int = ...,
+        alpha: float | None = ...,
+        norm: str | Normalize | None = ...,
+        cmap: str | Colormap | None = ...,
+        vmin: float | None = ...,
+        vmax: float | None = ...,
+        origin: Literal["upper", "lower"] | None = ...,
+        resize: bool = ...,
+        *,
+        colorizer: Colorizer | None = ...,
+        **kwargs
+    ) -> FigureImage: ...
+    def set_size_inches(
+        self, w: float | tuple[float, float], h: float | None = ..., forward: bool = ...
+    ) -> None: ...
+    def get_size_inches(self) -> np.ndarray: ...
+    def get_figwidth(self) -> float: ...
+    def get_figheight(self) -> float: ...
+    def get_dpi(self) -> float: ...
+    def set_dpi(self, val: float) -> None: ...
+    def set_figwidth(self, val: float, forward: bool = ...) -> None: ...
+    def set_figheight(self, val: float, forward: bool = ...) -> None: ...
+    def clear(self, keep_observers: bool = ...) -> None: ...
+    def draw_without_rendering(self) -> None: ...
+    def draw_artist(self, a: Artist) -> None: ...
+    def add_axobserver(self, func: Callable[[Figure], Any]) -> None: ...
+    def savefig(
+        self,
+        fname: str | os.PathLike | IO,
+        *,
+        transparent: bool | None = ...,
+        **kwargs
+    ) -> None: ...
+    def ginput(
+        self,
+        n: int = ...,
+        timeout: float = ...,
+        show_clicks: bool = ...,
+        mouse_add: MouseButton = ...,
+        mouse_pop: MouseButton = ...,
+        mouse_stop: MouseButton = ...,
+    ) -> list[tuple[int, int]]: ...
+    def waitforbuttonpress(self, timeout: float = ...) -> None | bool: ...
+    def tight_layout(
+        self,
+        *,
+        pad: float = ...,
+        h_pad: float | None = ...,
+        w_pad: float | None = ...,
+        rect: tuple[float, float, float, float] | None = ...
+    ) -> None: ...
+
+def figaspect(
+    arg: float | ArrayLike,
+) -> np.ndarray[tuple[Literal[2]], np.dtype[np.float64]]: ...

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/font_manager.py

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

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/font_manager.pyi

@@ -0,0 +1,136 @@
+from dataclasses import dataclass
+import os
+
+from matplotlib._afm import AFM
+from matplotlib import ft2font
+
+from pathlib import Path
+
+from collections.abc import Iterable
+from typing import Any, Literal
+
+font_scalings: dict[str | None, float]
+stretch_dict: dict[str, int]
+weight_dict: dict[str, int]
+font_family_aliases: set[str]
+MSFolders: str
+MSFontDirectories: list[str]
+MSUserFontDirectories: list[str]
+X11FontDirectories: list[str]
+OSXFontDirectories: list[str]
+
+def get_fontext_synonyms(fontext: str) -> list[str]: ...
+def list_fonts(directory: str, extensions: Iterable[str]) -> list[str]: ...
+def win32FontDirectory() -> str: ...
+def _get_fontconfig_fonts() -> list[Path]: ...
+def findSystemFonts(
+    fontpaths: Iterable[str | os.PathLike | Path] | None = ..., fontext: str = ...
+) -> list[str]: ...
+@dataclass
+class FontEntry:
+    fname: str = ...
+    name: str = ...
+    style: str = ...
+    variant: str = ...
+    weight: str | int = ...
+    stretch: str = ...
+    size: str = ...
+    def _repr_html_(self) -> str: ...
+    def _repr_png_(self) -> bytes: ...
+
+def ttfFontProperty(font: ft2font.FT2Font) -> FontEntry: ...
+def afmFontProperty(fontpath: str, font: AFM) -> FontEntry: ...
+
+class FontProperties:
+    def __init__(
+        self,
+        family: str | Iterable[str] | None = ...,
+        style: Literal["normal", "italic", "oblique"] | None = ...,
+        variant: Literal["normal", "small-caps"] | None = ...,
+        weight: int | str | None = ...,
+        stretch: int | str | None = ...,
+        size: float | str | None = ...,
+        fname: str | os.PathLike | Path | None = ...,
+        math_fontfamily: str | None = ...,
+    ) -> None: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def get_family(self) -> list[str]: ...
+    def get_name(self) -> str: ...
+    def get_style(self) -> Literal["normal", "italic", "oblique"]: ...
+    def get_variant(self) -> Literal["normal", "small-caps"]: ...
+    def get_weight(self) -> int | str: ...
+    def get_stretch(self) -> int | str: ...
+    def get_size(self) -> float: ...
+    def get_file(self) -> str | bytes | None: ...
+    def get_fontconfig_pattern(self) -> dict[str, list[Any]]: ...
+    def set_family(self, family: str | Iterable[str] | None) -> None: ...
+    def set_style(
+        self, style: Literal["normal", "italic", "oblique"] | None
+    ) -> None: ...
+    def set_variant(self, variant: Literal["normal", "small-caps"] | None) -> None: ...
+    def set_weight(self, weight: int | str | None) -> None: ...
+    def set_stretch(self, stretch: int | str | None) -> None: ...
+    def set_size(self, size: float | str | None) -> None: ...
+    def set_file(self, file: str | os.PathLike | Path | None) -> None: ...
+    def set_fontconfig_pattern(self, pattern: str) -> None: ...
+    def get_math_fontfamily(self) -> str: ...
+    def set_math_fontfamily(self, fontfamily: str | None) -> None: ...
+    def copy(self) -> FontProperties: ...
+    # Aliases
+    set_name = set_family
+    get_slant = get_style
+    set_slant = set_style
+    get_size_in_points = get_size
+
+def json_dump(data: FontManager, filename: str | Path | os.PathLike) -> None: ...
+def json_load(filename: str | Path | os.PathLike) -> FontManager: ...
+
+class FontManager:
+    __version__: int
+    default_size: float | None
+    defaultFamily: dict[str, str]
+    afmlist: list[FontEntry]
+    ttflist: list[FontEntry]
+    def __init__(self, size: float | None = ..., weight: str = ...) -> None: ...
+    def addfont(self, path: str | Path | os.PathLike) -> None: ...
+    @property
+    def defaultFont(self) -> dict[str, str]: ...
+    def get_default_weight(self) -> str: ...
+    @staticmethod
+    def get_default_size() -> float: ...
+    def set_default_weight(self, weight: str) -> None: ...
+    def score_family(
+        self, families: str | list[str] | tuple[str], family2: str
+    ) -> float: ...
+    def score_style(self, style1: str, style2: str) -> float: ...
+    def score_variant(self, variant1: str, variant2: str) -> float: ...
+    def score_stretch(self, stretch1: str | int, stretch2: str | int) -> float: ...
+    def score_weight(self, weight1: str | float, weight2: str | float) -> float: ...
+    def score_size(self, size1: str | float, size2: str | float) -> float: ...
+    def findfont(
+        self,
+        prop: str | FontProperties,
+        fontext: Literal["ttf", "afm"] = ...,
+        directory: str | None = ...,
+        fallback_to_default: bool = ...,
+        rebuild_if_missing: bool = ...,
+    ) -> str: ...
+    def get_font_names(self) -> list[str]: ...
+
+def is_opentype_cff_font(filename: str) -> bool: ...
+def get_font(
+    font_filepaths: Iterable[str | Path | bytes] | str | Path | bytes,
+    hinting_factor: int | None = ...,
+) -> ft2font.FT2Font: ...
+
+fontManager: FontManager
+
+def findfont(
+    prop: str | FontProperties,
+    fontext: Literal["ttf", "afm"] = ...,
+    directory: str | None = ...,
+    fallback_to_default: bool = ...,
+    rebuild_if_missing: bool = ...,
+) -> str: ...
+def get_font_names() -> list[str]: ...

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/ft2font.cpython-311-x86_64-linux-gnu.so

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

outputs/audit_venv/lib/python3.11/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]: ...

outputs/audit_venv/lib/python3.11/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

outputs/audit_venv/lib/python3.11/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) -> GridSpecBase: ...
+    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: ...

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/hatch.py

@@ -0,0 +1,225 @@
+"""Contains classes for generating hatch patterns."""
+
+import numpy as np
+
+from matplotlib import _api
+from matplotlib.path import Path
+
+
+class HatchPatternBase:
+    """The base class for a hatch pattern."""
+    pass
+
+
+class HorizontalHatch(HatchPatternBase):
+    def __init__(self, hatch, density):
+        self.num_lines = int((hatch.count('-') + hatch.count('+')) * density)
+        self.num_vertices = self.num_lines * 2
+
+    def set_vertices_and_codes(self, vertices, codes):
+        steps, stepsize = np.linspace(0.0, 1.0, self.num_lines, False,
+                                      retstep=True)
+        steps += stepsize / 2.
+        vertices[0::2, 0] = 0.0
+        vertices[0::2, 1] = steps
+        vertices[1::2, 0] = 1.0
+        vertices[1::2, 1] = steps
+        codes[0::2] = Path.MOVETO
+        codes[1::2] = Path.LINETO
+
+
+class VerticalHatch(HatchPatternBase):
+    def __init__(self, hatch, density):
+        self.num_lines = int((hatch.count('|') + hatch.count('+')) * density)
+        self.num_vertices = self.num_lines * 2
+
+    def set_vertices_and_codes(self, vertices, codes):
+        steps, stepsize = np.linspace(0.0, 1.0, self.num_lines, False,
+                                      retstep=True)
+        steps += stepsize / 2.
+        vertices[0::2, 0] = steps
+        vertices[0::2, 1] = 0.0
+        vertices[1::2, 0] = steps
+        vertices[1::2, 1] = 1.0
+        codes[0::2] = Path.MOVETO
+        codes[1::2] = Path.LINETO
+
+
+class NorthEastHatch(HatchPatternBase):
+    def __init__(self, hatch, density):
+        self.num_lines = int(
+            (hatch.count('/') + hatch.count('x') + hatch.count('X')) * density)
+        if self.num_lines:
+            self.num_vertices = (self.num_lines + 1) * 2
+        else:
+            self.num_vertices = 0
+
+    def set_vertices_and_codes(self, vertices, codes):
+        steps = np.linspace(-0.5, 0.5, self.num_lines + 1)
+        vertices[0::2, 0] = 0.0 + steps
+        vertices[0::2, 1] = 0.0 - steps
+        vertices[1::2, 0] = 1.0 + steps
+        vertices[1::2, 1] = 1.0 - steps
+        codes[0::2] = Path.MOVETO
+        codes[1::2] = Path.LINETO
+
+
+class SouthEastHatch(HatchPatternBase):
+    def __init__(self, hatch, density):
+        self.num_lines = int(
+            (hatch.count('\\') + hatch.count('x') + hatch.count('X'))
+            * density)
+        if self.num_lines:
+            self.num_vertices = (self.num_lines + 1) * 2
+        else:
+            self.num_vertices = 0
+
+    def set_vertices_and_codes(self, vertices, codes):
+        steps = np.linspace(-0.5, 0.5, self.num_lines + 1)
+        vertices[0::2, 0] = 0.0 + steps
+        vertices[0::2, 1] = 1.0 + steps
+        vertices[1::2, 0] = 1.0 + steps
+        vertices[1::2, 1] = 0.0 + steps
+        codes[0::2] = Path.MOVETO
+        codes[1::2] = Path.LINETO
+
+
+class Shapes(HatchPatternBase):
+    filled = False
+
+    def __init__(self, hatch, density):
+        if self.num_rows == 0:
+            self.num_shapes = 0
+            self.num_vertices = 0
+        else:
+            self.num_shapes = ((self.num_rows // 2 + 1) * (self.num_rows + 1) +
+                               (self.num_rows // 2) * self.num_rows)
+            self.num_vertices = (self.num_shapes *
+                                 len(self.shape_vertices) *
+                                 (1 if self.filled else 2))
+
+    def set_vertices_and_codes(self, vertices, codes):
+        offset = 1.0 / self.num_rows
+        shape_vertices = self.shape_vertices * offset * self.size
+        shape_codes = self.shape_codes
+        if not self.filled:
+            shape_vertices = np.concatenate(  # Forward, then backward.
+                [shape_vertices, shape_vertices[::-1] * 0.9])
+            shape_codes = np.concatenate([shape_codes, shape_codes])
+        vertices_parts = []
+        codes_parts = []
+        for row in range(self.num_rows + 1):
+            if row % 2 == 0:
+                cols = np.linspace(0, 1, self.num_rows + 1)
+            else:
+                cols = np.linspace(offset / 2, 1 - offset / 2, self.num_rows)
+            row_pos = row * offset
+            for col_pos in cols:
+                vertices_parts.append(shape_vertices + [col_pos, row_pos])
+                codes_parts.append(shape_codes)
+        np.concatenate(vertices_parts, out=vertices)
+        np.concatenate(codes_parts, out=codes)
+
+
+class Circles(Shapes):
+    def __init__(self, hatch, density):
+        path = Path.unit_circle()
+        self.shape_vertices = path.vertices
+        self.shape_codes = path.codes
+        super().__init__(hatch, density)
+
+
+class SmallCircles(Circles):
+    size = 0.2
+
+    def __init__(self, hatch, density):
+        self.num_rows = (hatch.count('o')) * density
+        super().__init__(hatch, density)
+
+
+class LargeCircles(Circles):
+    size = 0.35
+
+    def __init__(self, hatch, density):
+        self.num_rows = (hatch.count('O')) * density
+        super().__init__(hatch, density)
+
+
+class SmallFilledCircles(Circles):
+    size = 0.1
+    filled = True
+
+    def __init__(self, hatch, density):
+        self.num_rows = (hatch.count('.')) * density
+        super().__init__(hatch, density)
+
+
+class Stars(Shapes):
+    size = 1.0 / 3.0
+    filled = True
+
+    def __init__(self, hatch, density):
+        self.num_rows = (hatch.count('*')) * density
+        path = Path.unit_regular_star(5)
+        self.shape_vertices = path.vertices
+        self.shape_codes = np.full(len(self.shape_vertices), Path.LINETO,
+                                   dtype=Path.code_type)
+        self.shape_codes[0] = Path.MOVETO
+        super().__init__(hatch, density)
+
+_hatch_types = [
+    HorizontalHatch,
+    VerticalHatch,
+    NorthEastHatch,
+    SouthEastHatch,
+    SmallCircles,
+    LargeCircles,
+    SmallFilledCircles,
+    Stars
+    ]
+
+
+def _validate_hatch_pattern(hatch):
+    valid_hatch_patterns = set(r'-+|/\xXoO.*')
+    if hatch is not None:
+        invalids = set(hatch).difference(valid_hatch_patterns)
+        if invalids:
+            valid = ''.join(sorted(valid_hatch_patterns))
+            invalids = ''.join(sorted(invalids))
+            _api.warn_deprecated(
+                '3.4',
+                removal='3.11',  # one release after custom hatches (#20690)
+                message=f'hatch must consist of a string of "{valid}" or '
+                        'None, but found the following invalid values '
+                        f'"{invalids}". Passing invalid values is deprecated '
+                        'since %(since)s and will become an error in %(removal)s.'
+            )
+
+
+def get_path(hatchpattern, density=6):
+    """
+    Given a hatch specifier, *hatchpattern*, generates Path to render
+    the hatch in a unit square.  *density* is the number of lines per
+    unit square.
+    """
+    density = int(density)
+
+    patterns = [hatch_type(hatchpattern, density)
+                for hatch_type in _hatch_types]
+    num_vertices = sum([pattern.num_vertices for pattern in patterns])
+
+    if num_vertices == 0:
+        return Path(np.empty((0, 2)))
+
+    vertices = np.empty((num_vertices, 2))
+    codes = np.empty(num_vertices, Path.code_type)
+
+    cursor = 0
+    for pattern in patterns:
+        if pattern.num_vertices != 0:
+            vertices_chunk = vertices[cursor:cursor + pattern.num_vertices]
+            codes_chunk = codes[cursor:cursor + pattern.num_vertices]
+            pattern.set_vertices_and_codes(vertices_chunk, codes_chunk)
+            cursor += pattern.num_vertices
+
+    return Path(vertices, codes)

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/hatch.pyi

@@ -0,0 +1,68 @@
+from matplotlib.path import Path
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+class HatchPatternBase: ...
+
+class HorizontalHatch(HatchPatternBase):
+    num_lines: int
+    num_vertices: int
+    def __init__(self, hatch: str, density: int) -> None: ...
+    def set_vertices_and_codes(self, vertices: ArrayLike, codes: ArrayLike) -> None: ...
+
+class VerticalHatch(HatchPatternBase):
+    num_lines: int
+    num_vertices: int
+    def __init__(self, hatch: str, density: int) -> None: ...
+    def set_vertices_and_codes(self, vertices: ArrayLike, codes: ArrayLike) -> None: ...
+
+class NorthEastHatch(HatchPatternBase):
+    num_lines: int
+    num_vertices: int
+    def __init__(self, hatch: str, density: int) -> None: ...
+    def set_vertices_and_codes(self, vertices: ArrayLike, codes: ArrayLike) -> None: ...
+
+class SouthEastHatch(HatchPatternBase):
+    num_lines: int
+    num_vertices: int
+    def __init__(self, hatch: str, density: int) -> None: ...
+    def set_vertices_and_codes(self, vertices: ArrayLike, codes: ArrayLike) -> None: ...
+
+class Shapes(HatchPatternBase):
+    filled: bool
+    num_shapes: int
+    num_vertices: int
+    def __init__(self, hatch: str, density: int) -> None: ...
+    def set_vertices_and_codes(self, vertices: ArrayLike, codes: ArrayLike) -> None: ...
+
+class Circles(Shapes):
+    shape_vertices: np.ndarray
+    shape_codes: np.ndarray
+    def __init__(self, hatch: str, density: int) -> None: ...
+
+class SmallCircles(Circles):
+    size: float
+    num_rows: int
+    def __init__(self, hatch: str, density: int) -> None: ...
+
+class LargeCircles(Circles):
+    size: float
+    num_rows: int
+    def __init__(self, hatch: str, density: int) -> None: ...
+
+class SmallFilledCircles(Circles):
+    size: float
+    filled: bool
+    num_rows: int
+    def __init__(self, hatch: str, density: int) -> None: ...
+
+class Stars(Shapes):
+    size: float
+    filled: bool
+    num_rows: int
+    shape_vertices: np.ndarray
+    shape_codes: np.ndarray
+    def __init__(self, hatch: str, density: int) -> None: ...
+
+def get_path(hatchpattern: str, density: int = ...) -> Path: ...

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/image.py

@@ -0,0 +1,1786 @@
+"""
+The image module supports basic image loading, rescaling and display
+operations.
+"""
+
+import math
+import os
+import logging
+from pathlib import Path
+import warnings
+
+import numpy as np
+import PIL.Image
+import PIL.PngImagePlugin
+
+import matplotlib as mpl
+from matplotlib import _api, cbook
+# For clarity, names from _image are given explicitly in this module
+from matplotlib import _image
+# For user convenience, the names from _image are also imported into
+# the image namespace
+from matplotlib._image import *  # noqa: F401, F403
+import matplotlib.artist as martist
+import matplotlib.colorizer as mcolorizer
+from matplotlib.backend_bases import FigureCanvasBase
+import matplotlib.colors as mcolors
+from matplotlib.transforms import (
+    Affine2D, BboxBase, Bbox, BboxTransform, BboxTransformTo,
+    IdentityTransform, TransformedBbox)
+
+_log = logging.getLogger(__name__)
+
+# map interpolation strings to module constants
+_interpd_ = {
+    'auto': _image.NEAREST,  # this will use nearest or Hanning...
+    'none': _image.NEAREST,  # fall back to nearest when not supported
+    'nearest': _image.NEAREST,
+    'bilinear': _image.BILINEAR,
+    'bicubic': _image.BICUBIC,
+    'spline16': _image.SPLINE16,
+    'spline36': _image.SPLINE36,
+    'hanning': _image.HANNING,
+    'hamming': _image.HAMMING,
+    'hermite': _image.HERMITE,
+    'kaiser': _image.KAISER,
+    'quadric': _image.QUADRIC,
+    'catrom': _image.CATROM,
+    'gaussian': _image.GAUSSIAN,
+    'bessel': _image.BESSEL,
+    'mitchell': _image.MITCHELL,
+    'sinc': _image.SINC,
+    'lanczos': _image.LANCZOS,
+    'blackman': _image.BLACKMAN,
+    'antialiased': _image.NEAREST,  # this will use nearest or Hanning...
+}
+
+interpolations_names = set(_interpd_)
+
+
+def composite_images(images, renderer, magnification=1.0):
+    """
+    Composite a number of RGBA images into one.  The images are
+    composited in the order in which they appear in the *images* list.
+
+    Parameters
+    ----------
+    images : list of Images
+        Each must have a `make_image` method.  For each image,
+        `can_composite` should return `True`, though this is not
+        enforced by this function.  Each image must have a purely
+        affine transformation with no shear.
+
+    renderer : `.RendererBase`
+
+    magnification : float, default: 1
+        The additional magnification to apply for the renderer in use.
+
+    Returns
+    -------
+    image : (M, N, 4) `numpy.uint8` array
+        The composited RGBA image.
+    offset_x, offset_y : float
+        The (left, bottom) offset where the composited image should be placed
+        in the output figure.
+    """
+    if len(images) == 0:
+        return np.empty((0, 0, 4), dtype=np.uint8), 0, 0
+
+    parts = []
+    bboxes = []
+    for image in images:
+        data, x, y, trans = image.make_image(renderer, magnification)
+        if data is not None:
+            x *= magnification
+            y *= magnification
+            parts.append((data, x, y, image._get_scalar_alpha()))
+            bboxes.append(
+                Bbox([[x, y], [x + data.shape[1], y + data.shape[0]]]))
+
+    if len(parts) == 0:
+        return np.empty((0, 0, 4), dtype=np.uint8), 0, 0
+
+    bbox = Bbox.union(bboxes)
+
+    output = np.zeros(
+        (int(bbox.height), int(bbox.width), 4), dtype=np.uint8)
+
+    for data, x, y, alpha in parts:
+        trans = Affine2D().translate(x - bbox.x0, y - bbox.y0)
+        _image.resample(data, output, trans, _image.NEAREST,
+                        resample=False, alpha=alpha)
+
+    return output, bbox.x0 / magnification, bbox.y0 / magnification
+
+
+def _draw_list_compositing_images(
+        renderer, parent, artists, suppress_composite=None):
+    """
+    Draw a sorted list of artists, compositing images into a single
+    image where possible.
+
+    For internal Matplotlib use only: It is here to reduce duplication
+    between `Figure.draw` and `Axes.draw`, but otherwise should not be
+    generally useful.
+    """
+    has_images = any(isinstance(x, _ImageBase) for x in artists)
+
+    # override the renderer default if suppressComposite is not None
+    not_composite = (suppress_composite if suppress_composite is not None
+                     else renderer.option_image_nocomposite())
+
+    if not_composite or not has_images:
+        for a in artists:
+            a.draw(renderer)
+    else:
+        # Composite any adjacent images together
+        image_group = []
+        mag = renderer.get_image_magnification()
+
+        def flush_images():
+            if len(image_group) == 1:
+                image_group[0].draw(renderer)
+            elif len(image_group) > 1:
+                data, l, b = composite_images(image_group, renderer, mag)
+                if data.size != 0:
+                    gc = renderer.new_gc()
+                    gc.set_clip_rectangle(parent.bbox)
+                    gc.set_clip_path(parent.get_clip_path())
+                    renderer.draw_image(gc, round(l), round(b), data)
+                    gc.restore()
+            del image_group[:]
+
+        for a in artists:
+            if (isinstance(a, _ImageBase) and a.can_composite() and
+                    a.get_clip_on() and not a.get_clip_path()):
+                image_group.append(a)
+            else:
+                flush_images()
+                a.draw(renderer)
+        flush_images()
+
+
+def _resample(
+        image_obj, data, out_shape, transform, *, resample=None, alpha=1):
+    """
+    Convenience wrapper around `._image.resample` to resample *data* to
+    *out_shape* (with a third dimension if *data* is RGBA) that takes care of
+    allocating the output array and fetching the relevant properties from the
+    Image object *image_obj*.
+    """
+    # AGG can only handle coordinates smaller than 24-bit signed integers,
+    # so raise errors if the input data is larger than _image.resample can
+    # handle.
+    msg = ('Data with more than {n} cannot be accurately displayed. '
+           'Downsampling to less than {n} before displaying. '
+           'To remove this warning, manually downsample your data.')
+    if data.shape[1] > 2**23:
+        warnings.warn(msg.format(n='2**23 columns'))
+        step = int(np.ceil(data.shape[1] / 2**23))
+        data = data[:, ::step]
+        transform = Affine2D().scale(step, 1) + transform
+    if data.shape[0] > 2**24:
+        warnings.warn(msg.format(n='2**24 rows'))
+        step = int(np.ceil(data.shape[0] / 2**24))
+        data = data[::step, :]
+        transform = Affine2D().scale(1, step) + transform
+    # decide if we need to apply anti-aliasing if the data is upsampled:
+    # compare the number of displayed pixels to the number of
+    # the data pixels.
+    interpolation = image_obj.get_interpolation()
+    if interpolation in ['antialiased', 'auto']:
+        # don't antialias if upsampling by an integer number or
+        # if zooming in more than a factor of 3
+        pos = np.array([[0, 0], [data.shape[1], data.shape[0]]])
+        disp = transform.transform(pos)
+        dispx = np.abs(np.diff(disp[:, 0]))
+        dispy = np.abs(np.diff(disp[:, 1]))
+        if ((dispx > 3 * data.shape[1] or
+                dispx == data.shape[1] or
+                dispx == 2 * data.shape[1]) and
+            (dispy > 3 * data.shape[0] or
+                dispy == data.shape[0] or
+                dispy == 2 * data.shape[0])):
+            interpolation = 'nearest'
+        else:
+            interpolation = 'hanning'
+    out = np.zeros(out_shape + data.shape[2:], data.dtype)  # 2D->2D, 3D->3D.
+    if resample is None:
+        resample = image_obj.get_resample()
+    _image.resample(data, out, transform,
+                    _interpd_[interpolation],
+                    resample,
+                    alpha,
+                    image_obj.get_filternorm(),
+                    image_obj.get_filterrad())
+    return out
+
+
+def _rgb_to_rgba(A):
+    """
+    Convert an RGB image to RGBA, as required by the image resample C++
+    extension.
+    """
+    rgba = np.zeros((A.shape[0], A.shape[1], 4), dtype=A.dtype)
+    rgba[:, :, :3] = A
+    if rgba.dtype == np.uint8:
+        rgba[:, :, 3] = 255
+    else:
+        rgba[:, :, 3] = 1.0
+    return rgba
+
+
+class _ImageBase(mcolorizer.ColorizingArtist):
+    """
+    Base class for images.
+
+    interpolation and cmap default to their rc settings
+
+    cmap is a colors.Colormap instance
+    norm is a colors.Normalize instance to map luminance to 0-1
+
+    extent is data axes (left, right, bottom, top) for making image plots
+    registered with data plots.  Default is to label the pixel
+    centers with the zero-based row and column indices.
+
+    Additional kwargs are matplotlib.artist properties
+    """
+    zorder = 0
+
+    def __init__(self, ax,
+                 cmap=None,
+                 norm=None,
+                 colorizer=None,
+                 interpolation=None,
+                 origin=None,
+                 filternorm=True,
+                 filterrad=4.0,
+                 resample=False,
+                 *,
+                 interpolation_stage=None,
+                 **kwargs
+                 ):
+        super().__init__(self._get_colorizer(cmap, norm, colorizer))
+        if origin is None:
+            origin = mpl.rcParams['image.origin']
+        _api.check_in_list(["upper", "lower"], origin=origin)
+        self.origin = origin
+        self.set_filternorm(filternorm)
+        self.set_filterrad(filterrad)
+        self.set_interpolation(interpolation)
+        self.set_interpolation_stage(interpolation_stage)
+        self.set_resample(resample)
+        self.axes = ax
+
+        self._imcache = None
+
+        self._internal_update(kwargs)
+
+    def __str__(self):
+        try:
+            shape = self.get_shape()
+            return f"{type(self).__name__}(shape={shape!r})"
+        except RuntimeError:
+            return type(self).__name__
+
+    def __getstate__(self):
+        # Save some space on the pickle by not saving the cache.
+        return {**super().__getstate__(), "_imcache": None}
+
+    def get_size(self):
+        """Return the size of the image as tuple (numrows, numcols)."""
+        return self.get_shape()[:2]
+
+    def get_shape(self):
+        """
+        Return the shape of the image as tuple (numrows, numcols, channels).
+        """
+        if self._A is None:
+            raise RuntimeError('You must first set the image array')
+
+        return self._A.shape
+
+    def set_alpha(self, alpha):
+        """
+        Set the alpha value used for blending - not supported on all backends.
+
+        Parameters
+        ----------
+        alpha : float or 2D array-like or None
+        """
+        martist.Artist._set_alpha_for_array(self, alpha)
+        if np.ndim(alpha) not in (0, 2):
+            raise TypeError('alpha must be a float, two-dimensional '
+                            'array, or None')
+        self._imcache = None
+
+    def _get_scalar_alpha(self):
+        """
+        Get a scalar alpha value to be applied to the artist as a whole.
+
+        If the alpha value is a matrix, the method returns 1.0 because pixels
+        have individual alpha values (see `~._ImageBase._make_image` for
+        details). If the alpha value is a scalar, the method returns said value
+        to be applied to the artist as a whole because pixels do not have
+        individual alpha values.
+        """
+        return 1.0 if self._alpha is None or np.ndim(self._alpha) > 0 \
+            else self._alpha
+
+    def changed(self):
+        """
+        Call this whenever the mappable is changed so observers can update.
+        """
+        self._imcache = None
+        super().changed()
+
+    def _make_image(self, A, in_bbox, out_bbox, clip_bbox, magnification=1.0,
+                    unsampled=False, round_to_pixel_border=True):
+        """
+        Normalize, rescale, and colormap the image *A* from the given *in_bbox*
+        (in data space), to the given *out_bbox* (in pixel space) clipped to
+        the given *clip_bbox* (also in pixel space), and magnified by the
+        *magnification* factor.
+
+        Parameters
+        ----------
+        A : ndarray
+
+            - a (M, N) array interpreted as scalar (greyscale) image,
+              with one of the dtypes `~numpy.float32`, `~numpy.float64`,
+              `~numpy.float128`, `~numpy.uint16` or `~numpy.uint8`.
+            - (M, N, 4) RGBA image with a dtype of `~numpy.float32`,
+              `~numpy.float64`, `~numpy.float128`, or `~numpy.uint8`.
+
+        in_bbox : `~matplotlib.transforms.Bbox`
+
+        out_bbox : `~matplotlib.transforms.Bbox`
+
+        clip_bbox : `~matplotlib.transforms.Bbox`
+
+        magnification : float, default: 1
+
+        unsampled : bool, default: False
+            If True, the image will not be scaled, but an appropriate
+            affine transformation will be returned instead.
+
+        round_to_pixel_border : bool, default: True
+            If True, the output image size will be rounded to the nearest pixel
+            boundary.  This makes the images align correctly with the Axes.
+            It should not be used if exact scaling is needed, such as for
+            `.FigureImage`.
+
+        Returns
+        -------
+        image : (M, N, 4) `numpy.uint8` array
+            The RGBA image, resampled unless *unsampled* is True.
+        x, y : float
+            The upper left corner where the image should be drawn, in pixel
+            space.
+        trans : `~matplotlib.transforms.Affine2D`
+            The affine transformation from image to pixel space.
+        """
+        if A is None:
+            raise RuntimeError('You must first set the image '
+                               'array or the image attribute')
+        if A.size == 0:
+            raise RuntimeError("_make_image must get a non-empty image. "
+                               "Your Artist's draw method must filter before "
+                               "this method is called.")
+
+        clipped_bbox = Bbox.intersection(out_bbox, clip_bbox)
+
+        if clipped_bbox is None:
+            return None, 0, 0, None
+
+        out_width_base = clipped_bbox.width * magnification
+        out_height_base = clipped_bbox.height * magnification
+
+        if out_width_base == 0 or out_height_base == 0:
+            return None, 0, 0, None
+
+        if self.origin == 'upper':
+            # Flip the input image using a transform.  This avoids the
+            # problem with flipping the array, which results in a copy
+            # when it is converted to contiguous in the C wrapper
+            t0 = Affine2D().translate(0, -A.shape[0]).scale(1, -1)
+        else:
+            t0 = IdentityTransform()
+
+        t0 += (
+            Affine2D()
+            .scale(
+                in_bbox.width / A.shape[1],
+                in_bbox.height / A.shape[0])
+            .translate(in_bbox.x0, in_bbox.y0)
+            + self.get_transform())
+
+        t = (t0
+             + (Affine2D()
+                .translate(-clipped_bbox.x0, -clipped_bbox.y0)
+                .scale(magnification)))
+
+        # So that the image is aligned with the edge of the Axes, we want to
+        # round up the output width to the next integer.  This also means
+        # scaling the transform slightly to account for the extra subpixel.
+        if ((not unsampled) and t.is_affine and round_to_pixel_border and
+                (out_width_base % 1.0 != 0.0 or out_height_base % 1.0 != 0.0)):
+            out_width = math.ceil(out_width_base)
+            out_height = math.ceil(out_height_base)
+            extra_width = (out_width - out_width_base) / out_width_base
+            extra_height = (out_height - out_height_base) / out_height_base
+            t += Affine2D().scale(1.0 + extra_width, 1.0 + extra_height)
+        else:
+            out_width = int(out_width_base)
+            out_height = int(out_height_base)
+        out_shape = (out_height, out_width)
+
+        if not unsampled:
+            if not (A.ndim == 2 or A.ndim == 3 and A.shape[-1] in (3, 4)):
+                raise ValueError(f"Invalid shape {A.shape} for image data")
+
+            # if antialiased, this needs to change as window sizes
+            # change:
+            interpolation_stage = self._interpolation_stage
+            if interpolation_stage in ['antialiased', 'auto']:
+                pos = np.array([[0, 0], [A.shape[1], A.shape[0]]])
+                disp = t.transform(pos)
+                dispx = np.abs(np.diff(disp[:, 0])) / A.shape[1]
+                dispy = np.abs(np.diff(disp[:, 1])) / A.shape[0]
+                if (dispx < 3) or (dispy < 3):
+                    interpolation_stage = 'rgba'
+                else:
+                    interpolation_stage = 'data'
+
+            if A.ndim == 2 and interpolation_stage == 'data':
+                # if we are a 2D array, then we are running through the
+                # norm + colormap transformation.  However, in general the
+                # input data is not going to match the size on the screen so we
+                # have to resample to the correct number of pixels
+
+                if A.dtype.kind == 'f':  # Float dtype: scale to same dtype.
+                    scaled_dtype = np.dtype("f8" if A.dtype.itemsize > 4 else "f4")
+                    if scaled_dtype.itemsize < A.dtype.itemsize:
+                        _api.warn_external(f"Casting input data from {A.dtype}"
+                                           f" to {scaled_dtype} for imshow.")
+                else:  # Int dtype, likely.
+                    # TODO slice input array first
+                    # Scale to appropriately sized float: use float32 if the
+                    # dynamic range is small, to limit the memory footprint.
+                    da = A.max().astype("f8") - A.min().astype("f8")
+                    scaled_dtype = "f8" if da > 1e8 else "f4"
+
+                # resample the input data to the correct resolution and shape
+                A_resampled = _resample(self, A.astype(scaled_dtype), out_shape, t)
+
+                # if using NoNorm, cast back to the original datatype
+                if isinstance(self.norm, mcolors.NoNorm):
+                    A_resampled = A_resampled.astype(A.dtype)
+
+                # Compute out_mask (what screen pixels include "bad" data
+                # pixels) and out_alpha (to what extent screen pixels are
+                # covered by data pixels: 0 outside the data extent, 1 inside
+                # (even for bad data), and intermediate values at the edges).
+                mask = (np.where(A.mask, np.float32(np.nan), np.float32(1))
+                        if A.mask.shape == A.shape  # nontrivial mask
+                        else np.ones_like(A, np.float32))
+                # we always have to interpolate the mask to account for
+                # non-affine transformations
+                out_alpha = _resample(self, mask, out_shape, t, resample=True)
+                del mask  # Make sure we don't use mask anymore!
+                out_mask = np.isnan(out_alpha)
+                out_alpha[out_mask] = 1
+                # Apply the pixel-by-pixel alpha values if present
+                alpha = self.get_alpha()
+                if alpha is not None and np.ndim(alpha) > 0:
+                    out_alpha *= _resample(self, alpha, out_shape, t, resample=True)
+                # mask and run through the norm
+                resampled_masked = np.ma.masked_array(A_resampled, out_mask)
+                output = self.norm(resampled_masked)
+            else:
+                if A.ndim == 2:  # interpolation_stage = 'rgba'
+                    self.norm.autoscale_None(A)
+                    A = self.to_rgba(A)
+                alpha = self.get_alpha()
+                if alpha is None:  # alpha parameter not specified
+                    if A.shape[2] == 3:  # image has no alpha channel
+                        output_alpha = 255 if A.dtype == np.uint8 else 1.0
+                    else:
+                        output_alpha = _resample(  # resample alpha channel
+                            self, A[..., 3], out_shape, t)
+                    output = _resample(  # resample rgb channels
+                        self, _rgb_to_rgba(A[..., :3]), out_shape, t)
+                elif np.ndim(alpha) > 0:  # Array alpha
+                    # user-specified array alpha overrides the existing alpha channel
+                    output_alpha = _resample(self, alpha, out_shape, t)
+                    output = _resample(
+                        self, _rgb_to_rgba(A[..., :3]), out_shape, t)
+                else:  # Scalar alpha
+                    if A.shape[2] == 3:  # broadcast scalar alpha
+                        output_alpha = (255 * alpha) if A.dtype == np.uint8 else alpha
+                    else:  # or apply scalar alpha to existing alpha channel
+                        output_alpha = _resample(self, A[..., 3], out_shape, t) * alpha
+                    output = _resample(
+                        self, _rgb_to_rgba(A[..., :3]), out_shape, t)
+                output[..., 3] = output_alpha  # recombine rgb and alpha
+
+            # output is now either a 2D array of normed (int or float) data
+            # or an RGBA array of re-sampled input
+            output = self.to_rgba(output, bytes=True, norm=False)
+            # output is now a correctly sized RGBA array of uint8
+
+            # Apply alpha *after* if the input was greyscale without a mask
+            if A.ndim == 2:
+                alpha = self._get_scalar_alpha()
+                alpha_channel = output[:, :, 3]
+                alpha_channel[:] = (  # Assignment will cast to uint8.
+                    alpha_channel.astype(np.float32) * out_alpha * alpha)
+
+        else:
+            if self._imcache is None:
+                self._imcache = self.to_rgba(A, bytes=True, norm=(A.ndim == 2))
+            output = self._imcache
+
+            # Subset the input image to only the part that will be displayed.
+            subset = TransformedBbox(clip_bbox, t0.inverted()).frozen()
+            output = output[
+                int(max(subset.ymin, 0)):
+                int(min(subset.ymax + 1, output.shape[0])),
+                int(max(subset.xmin, 0)):
+                int(min(subset.xmax + 1, output.shape[1]))]
+
+            t = Affine2D().translate(
+                int(max(subset.xmin, 0)), int(max(subset.ymin, 0))) + t
+
+        return output, clipped_bbox.x0, clipped_bbox.y0, t
+
+    def make_image(self, renderer, magnification=1.0, unsampled=False):
+        """
+        Normalize, rescale, and colormap this image's data for rendering using
+        *renderer*, with the given *magnification*.
+
+        If *unsampled* is True, the image will not be scaled, but an
+        appropriate affine transformation will be returned instead.
+
+        Returns
+        -------
+        image : (M, N, 4) `numpy.uint8` array
+            The RGBA image, resampled unless *unsampled* is True.
+        x, y : float
+            The upper left corner where the image should be drawn, in pixel
+            space.
+        trans : `~matplotlib.transforms.Affine2D`
+            The affine transformation from image to pixel space.
+        """
+        raise NotImplementedError('The make_image method must be overridden')
+
+    def _check_unsampled_image(self):
+        """
+        Return whether the image is better to be drawn unsampled.
+
+        The derived class needs to override it.
+        """
+        return False
+
+    @martist.allow_rasterization
+    def draw(self, renderer):
+        # if not visible, declare victory and return
+        if not self.get_visible():
+            self.stale = False
+            return
+        # for empty images, there is nothing to draw!
+        if self.get_array().size == 0:
+            self.stale = False
+            return
+        # actually render the image.
+        gc = renderer.new_gc()
+        self._set_gc_clip(gc)
+        gc.set_alpha(self._get_scalar_alpha())
+        gc.set_url(self.get_url())
+        gc.set_gid(self.get_gid())
+        if (renderer.option_scale_image()  # Renderer supports transform kwarg.
+                and self._check_unsampled_image()
+                and self.get_transform().is_affine):
+            im, l, b, trans = self.make_image(renderer, unsampled=True)
+            if im is not None:
+                trans = Affine2D().scale(im.shape[1], im.shape[0]) + trans
+                renderer.draw_image(gc, l, b, im, trans)
+        else:
+            im, l, b, trans = self.make_image(
+                renderer, renderer.get_image_magnification())
+            if im is not None:
+                renderer.draw_image(gc, l, b, im)
+        gc.restore()
+        self.stale = False
+
+    def contains(self, mouseevent):
+        """Test whether the mouse event occurred within the image."""
+        if (self._different_canvas(mouseevent)
+                # This doesn't work for figimage.
+                or not self.axes.contains(mouseevent)[0]):
+            return False, {}
+        # TODO: make sure this is consistent with patch and patch
+        # collection on nonlinear transformed coordinates.
+        # TODO: consider returning image coordinates (shouldn't
+        # be too difficult given that the image is rectilinear
+        trans = self.get_transform().inverted()
+        x, y = trans.transform([mouseevent.x, mouseevent.y])
+        xmin, xmax, ymin, ymax = self.get_extent()
+        # This checks xmin <= x <= xmax *or* xmax <= x <= xmin.
+        inside = (x is not None and (x - xmin) * (x - xmax) <= 0
+                  and y is not None and (y - ymin) * (y - ymax) <= 0)
+        return inside, {}
+
+    def write_png(self, fname):
+        """Write the image to png file *fname*."""
+        im = self.to_rgba(self._A[::-1] if self.origin == 'lower' else self._A,
+                          bytes=True, norm=True)
+        PIL.Image.fromarray(im).save(fname, format="png")
+
+    @staticmethod
+    def _normalize_image_array(A):
+        """
+        Check validity of image-like input *A* and normalize it to a format suitable for
+        Image subclasses.
+        """
+        A = cbook.safe_masked_invalid(A, copy=True)
+        if A.dtype != np.uint8 and not np.can_cast(A.dtype, float, "same_kind"):
+            raise TypeError(f"Image data of dtype {A.dtype} cannot be "
+                            f"converted to float")
+        if A.ndim == 3 and A.shape[-1] == 1:
+            A = A.squeeze(-1)  # If just (M, N, 1), assume scalar and apply colormap.
+        if not (A.ndim == 2 or A.ndim == 3 and A.shape[-1] in [3, 4]):
+            raise TypeError(f"Invalid shape {A.shape} for image data")
+        if A.ndim == 3:
+            # If the input data has values outside the valid range (after
+            # normalisation), we issue a warning and then clip X to the bounds
+            # - otherwise casting wraps extreme values, hiding outliers and
+            # making reliable interpretation impossible.
+            high = 255 if np.issubdtype(A.dtype, np.integer) else 1
+            if A.min() < 0 or high < A.max():
+                _log.warning(
+                    'Clipping input data to the valid range for imshow with '
+                    'RGB data ([0..1] for floats or [0..255] for integers). '
+                    'Got range [%s..%s].',
+                    A.min(), A.max()
+                )
+                A = np.clip(A, 0, high)
+            # Cast unsupported integer types to uint8
+            if A.dtype != np.uint8 and np.issubdtype(A.dtype, np.integer):
+                A = A.astype(np.uint8)
+        return A
+
+    def set_data(self, A):
+        """
+        Set the image array.
+
+        Note that this function does *not* update the normalization used.
+
+        Parameters
+        ----------
+        A : array-like or `PIL.Image.Image`
+        """
+        if isinstance(A, PIL.Image.Image):
+            A = pil_to_array(A)  # Needed e.g. to apply png palette.
+        self._A = self._normalize_image_array(A)
+        self._imcache = None
+        self.stale = True
+
+    def set_array(self, A):
+        """
+        Retained for backwards compatibility - use set_data instead.
+
+        Parameters
+        ----------
+        A : array-like
+        """
+        # This also needs to be here to override the inherited
+        # cm.ScalarMappable.set_array method so it is not invoked by mistake.
+        self.set_data(A)
+
+    def get_interpolation(self):
+        """
+        Return the interpolation method the image uses when resizing.
+
+        One of 'auto', 'antialiased', 'nearest', 'bilinear', 'bicubic',
+        'spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser',
+        'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos',
+        or 'none'.
+        """
+        return self._interpolation
+
+    def set_interpolation(self, s):
+        """
+        Set the interpolation method the image uses when resizing.
+
+        If None, use :rc:`image.interpolation`. If 'none', the image is
+        shown as is without interpolating. 'none' is only supported in
+        agg, ps and pdf backends and will fall back to 'nearest' mode
+        for other backends.
+
+        Parameters
+        ----------
+        s : {'auto', 'nearest', 'bilinear', 'bicubic', 'spline16', \
+'spline36', 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric', 'catrom', \
+'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos', 'none'} or None
+        """
+        s = mpl._val_or_rc(s, 'image.interpolation').lower()
+        _api.check_in_list(interpolations_names, interpolation=s)
+        self._interpolation = s
+        self.stale = True
+
+    def get_interpolation_stage(self):
+        """
+        Return when interpolation happens during the transform to RGBA.
+
+        One of 'data', 'rgba', 'auto'.
+        """
+        return self._interpolation_stage
+
+    def set_interpolation_stage(self, s):
+        """
+        Set when interpolation happens during the transform to RGBA.
+
+        Parameters
+        ----------
+        s : {'data', 'rgba', 'auto'} or None
+            Whether to apply up/downsampling interpolation in data or RGBA
+            space.  If None, use :rc:`image.interpolation_stage`.
+            If 'auto' we will check upsampling rate and if less
+            than 3 then use 'rgba', otherwise use 'data'.
+        """
+        s = mpl._val_or_rc(s, 'image.interpolation_stage')
+        _api.check_in_list(['data', 'rgba', 'auto'], s=s)
+        self._interpolation_stage = s
+        self.stale = True
+
+    def can_composite(self):
+        """Return whether the image can be composited with its neighbors."""
+        trans = self.get_transform()
+        return (
+            self._interpolation != 'none' and
+            trans.is_affine and
+            trans.is_separable)
+
+    def set_resample(self, v):
+        """
+        Set whether image resampling is used.
+
+        Parameters
+        ----------
+        v : bool or None
+            If None, use :rc:`image.resample`.
+        """
+        v = mpl._val_or_rc(v, 'image.resample')
+        self._resample = v
+        self.stale = True
+
+    def get_resample(self):
+        """Return whether image resampling is used."""
+        return self._resample
+
+    def set_filternorm(self, filternorm):
+        """
+        Set whether the resize filter normalizes the weights.
+
+        See help for `~.Axes.imshow`.
+
+        Parameters
+        ----------
+        filternorm : bool
+        """
+        self._filternorm = bool(filternorm)
+        self.stale = True
+
+    def get_filternorm(self):
+        """Return whether the resize filter normalizes the weights."""
+        return self._filternorm
+
+    def set_filterrad(self, filterrad):
+        """
+        Set the resize filter radius only applicable to some
+        interpolation schemes -- see help for imshow
+
+        Parameters
+        ----------
+        filterrad : positive float
+        """
+        r = float(filterrad)
+        if r <= 0:
+            raise ValueError("The filter radius must be a positive number")
+        self._filterrad = r
+        self.stale = True
+
+    def get_filterrad(self):
+        """Return the filterrad setting."""
+        return self._filterrad
+
+
+class AxesImage(_ImageBase):
+    """
+    An image with pixels on a regular grid, attached to an Axes.
+
+    Parameters
+    ----------
+    ax : `~matplotlib.axes.Axes`
+        The Axes the image will belong to.
+    cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
+        The Colormap instance or registered colormap name used to map scalar
+        data to colors.
+    norm : str or `~matplotlib.colors.Normalize`
+        Maps luminance to 0-1.
+    interpolation : str, default: :rc:`image.interpolation`
+        Supported values are 'none', 'auto', 'nearest', 'bilinear',
+        'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', 'hermite',
+        'kaiser', 'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell',
+        'sinc', 'lanczos', 'blackman'.
+    interpolation_stage : {'data', 'rgba'}, default: 'data'
+        If 'data', interpolation
+        is carried out on the data provided by the user.  If 'rgba', the
+        interpolation is carried out after the colormapping has been
+        applied (visual interpolation).
+    origin : {'upper', 'lower'}, default: :rc:`image.origin`
+        Place the [0, 0] index of the array in the upper left or lower left
+        corner of the Axes. The convention 'upper' is typically used for
+        matrices and images.
+    extent : tuple, optional
+        The data axes (left, right, bottom, top) for making image plots
+        registered with data plots.  Default is to label the pixel
+        centers with the zero-based row and column indices.
+    filternorm : bool, default: True
+        A parameter for the antigrain image resize filter
+        (see the antigrain documentation).
+        If filternorm is set, the filter normalizes integer values and corrects
+        the rounding errors. It doesn't do anything with the source floating
+        point values, it corrects only integers according to the rule of 1.0
+        which means that any sum of pixel weights must be equal to 1.0. So,
+        the filter function must produce a graph of the proper shape.
+    filterrad : float > 0, default: 4
+        The filter radius for filters that have a radius parameter, i.e. when
+        interpolation is one of: 'sinc', 'lanczos' or 'blackman'.
+    resample : bool, default: False
+        When True, use a full resampling method. When False, only resample when
+        the output image is larger than the input image.
+    **kwargs : `~matplotlib.artist.Artist` properties
+    """
+
+    def __init__(self, ax,
+                 *,
+                 cmap=None,
+                 norm=None,
+                 colorizer=None,
+                 interpolation=None,
+                 origin=None,
+                 extent=None,
+                 filternorm=True,
+                 filterrad=4.0,
+                 resample=False,
+                 interpolation_stage=None,
+                 **kwargs
+                 ):
+
+        self._extent = extent
+
+        super().__init__(
+            ax,
+            cmap=cmap,
+            norm=norm,
+            colorizer=colorizer,
+            interpolation=interpolation,
+            origin=origin,
+            filternorm=filternorm,
+            filterrad=filterrad,
+            resample=resample,
+            interpolation_stage=interpolation_stage,
+            **kwargs
+        )
+
+    def get_window_extent(self, renderer=None):
+        x0, x1, y0, y1 = self._extent
+        bbox = Bbox.from_extents([x0, y0, x1, y1])
+        return bbox.transformed(self.get_transform())
+
+    def make_image(self, renderer, magnification=1.0, unsampled=False):
+        # docstring inherited
+        trans = self.get_transform()
+        # image is created in the canvas coordinate.
+        x1, x2, y1, y2 = self.get_extent()
+        bbox = Bbox(np.array([[x1, y1], [x2, y2]]))
+        transformed_bbox = TransformedBbox(bbox, trans)
+        clip = ((self.get_clip_box() or self.axes.bbox) if self.get_clip_on()
+                else self.get_figure(root=True).bbox)
+        return self._make_image(self._A, bbox, transformed_bbox, clip,
+                                magnification, unsampled=unsampled)
+
+    def _check_unsampled_image(self):
+        """Return whether the image would be better drawn unsampled."""
+        return self.get_interpolation() == "none"
+
+    def set_extent(self, extent, **kwargs):
+        """
+        Set the image extent.
+
+        Parameters
+        ----------
+        extent : 4-tuple of float
+            The position and size of the image as tuple
+            ``(left, right, bottom, top)`` in data coordinates.
+        **kwargs
+            Other parameters from which unit info (i.e., the *xunits*,
+            *yunits*, *zunits* (for 3D Axes), *runits* and *thetaunits* (for
+            polar Axes) entries are applied, if present.
+
+        Notes
+        -----
+        This updates `.Axes.dataLim`, and, if autoscaling, sets `.Axes.viewLim`
+        to tightly fit the image, regardless of `~.Axes.dataLim`.  Autoscaling
+        state is not changed, so a subsequent call to `.Axes.autoscale_view`
+        will redo the autoscaling in accord with `~.Axes.dataLim`.
+        """
+        (xmin, xmax), (ymin, ymax) = self.axes._process_unit_info(
+            [("x", [extent[0], extent[1]]),
+             ("y", [extent[2], extent[3]])],
+            kwargs)
+        if kwargs:
+            raise _api.kwarg_error("set_extent", kwargs)
+        xmin = self.axes._validate_converted_limits(
+            xmin, self.convert_xunits)
+        xmax = self.axes._validate_converted_limits(
+            xmax, self.convert_xunits)
+        ymin = self.axes._validate_converted_limits(
+            ymin, self.convert_yunits)
+        ymax = self.axes._validate_converted_limits(
+            ymax, self.convert_yunits)
+        extent = [xmin, xmax, ymin, ymax]
+
+        self._extent = extent
+        corners = (xmin, ymin), (xmax, ymax)
+        self.axes.update_datalim(corners)
+        self.sticky_edges.x[:] = [xmin, xmax]
+        self.sticky_edges.y[:] = [ymin, ymax]
+        if self.axes.get_autoscalex_on():
+            self.axes.set_xlim((xmin, xmax), auto=None)
+        if self.axes.get_autoscaley_on():
+            self.axes.set_ylim((ymin, ymax), auto=None)
+        self.stale = True
+
+    def get_extent(self):
+        """Return the image extent as tuple (left, right, bottom, top)."""
+        if self._extent is not None:
+            return self._extent
+        else:
+            sz = self.get_size()
+            numrows, numcols = sz
+            if self.origin == 'upper':
+                return (-0.5, numcols-0.5, numrows-0.5, -0.5)
+            else:
+                return (-0.5, numcols-0.5, -0.5, numrows-0.5)
+
+    def get_cursor_data(self, event):
+        """
+        Return the image value at the event position or *None* if the event is
+        outside the image.
+
+        See Also
+        --------
+        matplotlib.artist.Artist.get_cursor_data
+        """
+        xmin, xmax, ymin, ymax = self.get_extent()
+        if self.origin == 'upper':
+            ymin, ymax = ymax, ymin
+        arr = self.get_array()
+        data_extent = Bbox([[xmin, ymin], [xmax, ymax]])
+        array_extent = Bbox([[0, 0], [arr.shape[1], arr.shape[0]]])
+        trans = self.get_transform().inverted()
+        trans += BboxTransform(boxin=data_extent, boxout=array_extent)
+        point = trans.transform([event.x, event.y])
+        if any(np.isnan(point)):
+            return None
+        j, i = point.astype(int)
+        # Clip the coordinates at array bounds
+        if not (0 <= i < arr.shape[0]) or not (0 <= j < arr.shape[1]):
+            return None
+        else:
+            return arr[i, j]
+
+
+class NonUniformImage(AxesImage):
+    """
+    An image with pixels on a rectilinear grid.
+
+    In contrast to `.AxesImage`, where pixels are on a regular grid,
+    NonUniformImage allows rows and columns with individual heights / widths.
+
+    See also :doc:`/gallery/images_contours_and_fields/image_nonuniform`.
+    """
+
+    def __init__(self, ax, *, interpolation='nearest', **kwargs):
+        """
+        Parameters
+        ----------
+        ax : `~matplotlib.axes.Axes`
+            The Axes the image will belong to.
+        interpolation : {'nearest', 'bilinear'}, default: 'nearest'
+            The interpolation scheme used in the resampling.
+        **kwargs
+            All other keyword arguments are identical to those of `.AxesImage`.
+        """
+        super().__init__(ax, **kwargs)
+        self.set_interpolation(interpolation)
+
+    def _check_unsampled_image(self):
+        """Return False. Do not use unsampled image."""
+        return False
+
+    def make_image(self, renderer, magnification=1.0, unsampled=False):
+        # docstring inherited
+        if self._A is None:
+            raise RuntimeError('You must first set the image array')
+        if unsampled:
+            raise ValueError('unsampled not supported on NonUniformImage')
+        A = self._A
+        if A.ndim == 2:
+            if A.dtype != np.uint8:
+                A = self.to_rgba(A, bytes=True)
+            else:
+                A = np.repeat(A[:, :, np.newaxis], 4, 2)
+                A[:, :, 3] = 255
+        else:
+            if A.dtype != np.uint8:
+                A = (255*A).astype(np.uint8)
+            if A.shape[2] == 3:
+                B = np.zeros(tuple([*A.shape[0:2], 4]), np.uint8)
+                B[:, :, 0:3] = A
+                B[:, :, 3] = 255
+                A = B
+        l, b, r, t = self.axes.bbox.extents
+        width = int(((round(r) + 0.5) - (round(l) - 0.5)) * magnification)
+        height = int(((round(t) + 0.5) - (round(b) - 0.5)) * magnification)
+
+        invertedTransform = self.axes.transData.inverted()
+        x_pix = invertedTransform.transform(
+            [(x, b) for x in np.linspace(l, r, width)])[:, 0]
+        y_pix = invertedTransform.transform(
+            [(l, y) for y in np.linspace(b, t, height)])[:, 1]
+
+        if self._interpolation == "nearest":
+            x_mid = (self._Ax[:-1] + self._Ax[1:]) / 2
+            y_mid = (self._Ay[:-1] + self._Ay[1:]) / 2
+            x_int = x_mid.searchsorted(x_pix)
+            y_int = y_mid.searchsorted(y_pix)
+            # The following is equal to `A[y_int[:, None], x_int[None, :]]`,
+            # but many times faster.  Both casting to uint32 (to have an
+            # effectively 1D array) and manual index flattening matter.
+            im = (
+                np.ascontiguousarray(A).view(np.uint32).ravel()[
+                    np.add.outer(y_int * A.shape[1], x_int)]
+                .view(np.uint8).reshape((height, width, 4)))
+        else:  # self._interpolation == "bilinear"
+            # Use np.interp to compute x_int/x_float has similar speed.
+            x_int = np.clip(
+                self._Ax.searchsorted(x_pix) - 1, 0, len(self._Ax) - 2)
+            y_int = np.clip(
+                self._Ay.searchsorted(y_pix) - 1, 0, len(self._Ay) - 2)
+            idx_int = np.add.outer(y_int * A.shape[1], x_int)
+            x_frac = np.clip(
+                np.divide(x_pix - self._Ax[x_int], np.diff(self._Ax)[x_int],
+                          dtype=np.float32),  # Downcasting helps with speed.
+                0, 1)
+            y_frac = np.clip(
+                np.divide(y_pix - self._Ay[y_int], np.diff(self._Ay)[y_int],
+                          dtype=np.float32),
+                0, 1)
+            f00 = np.outer(1 - y_frac, 1 - x_frac)
+            f10 = np.outer(y_frac, 1 - x_frac)
+            f01 = np.outer(1 - y_frac, x_frac)
+            f11 = np.outer(y_frac, x_frac)
+            im = np.empty((height, width, 4), np.uint8)
+            for chan in range(4):
+                ac = A[:, :, chan].reshape(-1)  # reshape(-1) avoids a copy.
+                # Shifting the buffer start (`ac[offset:]`) avoids an array
+                # addition (`ac[idx_int + offset]`).
+                buf = f00 * ac[idx_int]
+                buf += f10 * ac[A.shape[1]:][idx_int]
+                buf += f01 * ac[1:][idx_int]
+                buf += f11 * ac[A.shape[1] + 1:][idx_int]
+                im[:, :, chan] = buf  # Implicitly casts to uint8.
+        return im, l, b, IdentityTransform()
+
+    def set_data(self, x, y, A):
+        """
+        Set the grid for the pixel centers, and the pixel values.
+
+        Parameters
+        ----------
+        x, y : 1D array-like
+            Monotonic arrays of shapes (N,) and (M,), respectively, specifying
+            pixel centers.
+        A : array-like
+            (M, N) `~numpy.ndarray` or masked array of values to be
+            colormapped, or (M, N, 3) RGB array, or (M, N, 4) RGBA array.
+        """
+        A = self._normalize_image_array(A)
+        x = np.array(x, np.float32)
+        y = np.array(y, np.float32)
+        if not (x.ndim == y.ndim == 1 and A.shape[:2] == y.shape + x.shape):
+            raise TypeError("Axes don't match array shape")
+        self._A = A
+        self._Ax = x
+        self._Ay = y
+        self._imcache = None
+        self.stale = True
+
+    def set_array(self, *args):
+        raise NotImplementedError('Method not supported')
+
+    def set_interpolation(self, s):
+        """
+        Parameters
+        ----------
+        s : {'nearest', 'bilinear'} or None
+            If None, use :rc:`image.interpolation`.
+        """
+        if s is not None and s not in ('nearest', 'bilinear'):
+            raise NotImplementedError('Only nearest neighbor and '
+                                      'bilinear interpolations are supported')
+        super().set_interpolation(s)
+
+    def get_extent(self):
+        if self._A is None:
+            raise RuntimeError('Must set data first')
+        return self._Ax[0], self._Ax[-1], self._Ay[0], self._Ay[-1]
+
+    def set_filternorm(self, filternorm):
+        pass
+
+    def set_filterrad(self, filterrad):
+        pass
+
+    def set_norm(self, norm):
+        if self._A is not None:
+            raise RuntimeError('Cannot change colors after loading data')
+        super().set_norm(norm)
+
+    def set_cmap(self, cmap):
+        if self._A is not None:
+            raise RuntimeError('Cannot change colors after loading data')
+        super().set_cmap(cmap)
+
+    def get_cursor_data(self, event):
+        # docstring inherited
+        x, y = event.xdata, event.ydata
+        if (x < self._Ax[0] or x > self._Ax[-1] or
+                y < self._Ay[0] or y > self._Ay[-1]):
+            return None
+        j = np.searchsorted(self._Ax, x) - 1
+        i = np.searchsorted(self._Ay, y) - 1
+        return self._A[i, j]
+
+
+class PcolorImage(AxesImage):
+    """
+    Make a pcolor-style plot with an irregular rectangular grid.
+
+    This uses a variation of the original irregular image code,
+    and it is used by pcolorfast for the corresponding grid type.
+    """
+
+    def __init__(self, ax,
+                 x=None,
+                 y=None,
+                 A=None,
+                 *,
+                 cmap=None,
+                 norm=None,
+                 colorizer=None,
+                 **kwargs
+                 ):
+        """
+        Parameters
+        ----------
+        ax : `~matplotlib.axes.Axes`
+            The Axes the image will belong to.
+        x, y : 1D array-like, optional
+            Monotonic arrays of length N+1 and M+1, respectively, specifying
+            rectangle boundaries.  If not given, will default to
+            ``range(N + 1)`` and ``range(M + 1)``, respectively.
+        A : array-like
+            The data to be color-coded. The interpretation depends on the
+            shape:
+
+            - (M, N) `~numpy.ndarray` or masked array: values to be colormapped
+            - (M, N, 3): RGB array
+            - (M, N, 4): RGBA array
+
+        cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
+            The Colormap instance or registered colormap name used to map
+            scalar data to colors.
+        norm : str or `~matplotlib.colors.Normalize`
+            Maps luminance to 0-1.
+        **kwargs : `~matplotlib.artist.Artist` properties
+        """
+        super().__init__(ax, norm=norm, cmap=cmap, colorizer=colorizer)
+        self._internal_update(kwargs)
+        if A is not None:
+            self.set_data(x, y, A)
+
+    def make_image(self, renderer, magnification=1.0, unsampled=False):
+        # docstring inherited
+        if self._A is None:
+            raise RuntimeError('You must first set the image array')
+        if unsampled:
+            raise ValueError('unsampled not supported on PColorImage')
+
+        if self._imcache is None:
+            A = self.to_rgba(self._A, bytes=True)
+            self._imcache = np.pad(A, [(1, 1), (1, 1), (0, 0)], "constant")
+        padded_A = self._imcache
+        bg = mcolors.to_rgba(self.axes.patch.get_facecolor(), 0)
+        bg = (np.array(bg) * 255).astype(np.uint8)
+        if (padded_A[0, 0] != bg).all():
+            padded_A[[0, -1], :] = padded_A[:, [0, -1]] = bg
+
+        l, b, r, t = self.axes.bbox.extents
+        width = (round(r) + 0.5) - (round(l) - 0.5)
+        height = (round(t) + 0.5) - (round(b) - 0.5)
+        width = round(width * magnification)
+        height = round(height * magnification)
+        vl = self.axes.viewLim
+
+        x_pix = np.linspace(vl.x0, vl.x1, width)
+        y_pix = np.linspace(vl.y0, vl.y1, height)
+        x_int = self._Ax.searchsorted(x_pix)
+        y_int = self._Ay.searchsorted(y_pix)
+        im = (  # See comment in NonUniformImage.make_image re: performance.
+            padded_A.view(np.uint32).ravel()[
+                np.add.outer(y_int * padded_A.shape[1], x_int)]
+            .view(np.uint8).reshape((height, width, 4)))
+        return im, l, b, IdentityTransform()
+
+    def _check_unsampled_image(self):
+        return False
+
+    def set_data(self, x, y, A):
+        """
+        Set the grid for the rectangle boundaries, and the data values.
+
+        Parameters
+        ----------
+        x, y : 1D array-like, optional
+            Monotonic arrays of length N+1 and M+1, respectively, specifying
+            rectangle boundaries.  If not given, will default to
+            ``range(N + 1)`` and ``range(M + 1)``, respectively.
+        A : array-like
+            The data to be color-coded. The interpretation depends on the
+            shape:
+
+            - (M, N) `~numpy.ndarray` or masked array: values to be colormapped
+            - (M, N, 3): RGB array
+            - (M, N, 4): RGBA array
+        """
+        A = self._normalize_image_array(A)
+        x = np.arange(0., A.shape[1] + 1) if x is None else np.array(x, float).ravel()
+        y = np.arange(0., A.shape[0] + 1) if y is None else np.array(y, float).ravel()
+        if A.shape[:2] != (y.size - 1, x.size - 1):
+            raise ValueError(
+                "Axes don't match array shape. Got %s, expected %s." %
+                (A.shape[:2], (y.size - 1, x.size - 1)))
+        # For efficient cursor readout, ensure x and y are increasing.
+        if x[-1] < x[0]:
+            x = x[::-1]
+            A = A[:, ::-1]
+        if y[-1] < y[0]:
+            y = y[::-1]
+            A = A[::-1]
+        self._A = A
+        self._Ax = x
+        self._Ay = y
+        self._imcache = None
+        self.stale = True
+
+    def set_array(self, *args):
+        raise NotImplementedError('Method not supported')
+
+    def get_cursor_data(self, event):
+        # docstring inherited
+        x, y = event.xdata, event.ydata
+        if (x < self._Ax[0] or x > self._Ax[-1] or
+                y < self._Ay[0] or y > self._Ay[-1]):
+            return None
+        j = np.searchsorted(self._Ax, x) - 1
+        i = np.searchsorted(self._Ay, y) - 1
+        return self._A[i, j]
+
+
+class FigureImage(_ImageBase):
+    """An image attached to a figure."""
+
+    zorder = 0
+
+    _interpolation = 'nearest'
+
+    def __init__(self, fig,
+                 *,
+                 cmap=None,
+                 norm=None,
+                 colorizer=None,
+                 offsetx=0,
+                 offsety=0,
+                 origin=None,
+                 **kwargs
+                 ):
+        """
+        cmap is a colors.Colormap instance
+        norm is a colors.Normalize instance to map luminance to 0-1
+
+        kwargs are an optional list of Artist keyword args
+        """
+        super().__init__(
+            None,
+            norm=norm,
+            cmap=cmap,
+            colorizer=colorizer,
+            origin=origin
+        )
+        self.set_figure(fig)
+        self.ox = offsetx
+        self.oy = offsety
+        self._internal_update(kwargs)
+        self.magnification = 1.0
+
+    def get_extent(self):
+        """Return the image extent as tuple (left, right, bottom, top)."""
+        numrows, numcols = self.get_size()
+        return (-0.5 + self.ox, numcols-0.5 + self.ox,
+                -0.5 + self.oy, numrows-0.5 + self.oy)
+
+    def make_image(self, renderer, magnification=1.0, unsampled=False):
+        # docstring inherited
+        fig = self.get_figure(root=True)
+        fac = renderer.dpi/fig.dpi
+        # fac here is to account for pdf, eps, svg backends where
+        # figure.dpi is set to 72.  This means we need to scale the
+        # image (using magnification) and offset it appropriately.
+        bbox = Bbox([[self.ox/fac, self.oy/fac],
+                     [(self.ox/fac + self._A.shape[1]),
+                     (self.oy/fac + self._A.shape[0])]])
+        width, height = fig.get_size_inches()
+        width *= renderer.dpi
+        height *= renderer.dpi
+        clip = Bbox([[0, 0], [width, height]])
+        return self._make_image(
+            self._A, bbox, bbox, clip, magnification=magnification / fac,
+            unsampled=unsampled, round_to_pixel_border=False)
+
+    def set_data(self, A):
+        """Set the image array."""
+        super().set_data(A)
+        self.stale = True
+
+
+class BboxImage(_ImageBase):
+    """The Image class whose size is determined by the given bbox."""
+
+    def __init__(self, bbox,
+                 *,
+                 cmap=None,
+                 norm=None,
+                 colorizer=None,
+                 interpolation=None,
+                 origin=None,
+                 filternorm=True,
+                 filterrad=4.0,
+                 resample=False,
+                 **kwargs
+                 ):
+        """
+        cmap is a colors.Colormap instance
+        norm is a colors.Normalize instance to map luminance to 0-1
+
+        kwargs are an optional list of Artist keyword args
+        """
+        super().__init__(
+            None,
+            cmap=cmap,
+            norm=norm,
+            colorizer=colorizer,
+            interpolation=interpolation,
+            origin=origin,
+            filternorm=filternorm,
+            filterrad=filterrad,
+            resample=resample,
+            **kwargs
+        )
+        self.bbox = bbox
+
+    def get_window_extent(self, renderer=None):
+        if renderer is None:
+            renderer = self.get_figure()._get_renderer()
+
+        if isinstance(self.bbox, BboxBase):
+            return self.bbox
+        elif callable(self.bbox):
+            return self.bbox(renderer)
+        else:
+            raise ValueError("Unknown type of bbox")
+
+    def contains(self, mouseevent):
+        """Test whether the mouse event occurred within the image."""
+        if self._different_canvas(mouseevent) or not self.get_visible():
+            return False, {}
+        x, y = mouseevent.x, mouseevent.y
+        inside = self.get_window_extent().contains(x, y)
+        return inside, {}
+
+    def make_image(self, renderer, magnification=1.0, unsampled=False):
+        # docstring inherited
+        width, height = renderer.get_canvas_width_height()
+        bbox_in = self.get_window_extent(renderer).frozen()
+        bbox_in._points /= [width, height]
+        bbox_out = self.get_window_extent(renderer)
+        clip = Bbox([[0, 0], [width, height]])
+        self._transform = BboxTransformTo(clip)
+        return self._make_image(
+            self._A,
+            bbox_in, bbox_out, clip, magnification, unsampled=unsampled)
+
+
+def imread(fname, format=None):
+    """
+    Read an image from a file into an array.
+
+    .. note::
+
+        This function exists for historical reasons.  It is recommended to
+        use `PIL.Image.open` instead for loading images.
+
+    Parameters
+    ----------
+    fname : str or file-like
+        The image file to read: a filename, a URL or a file-like object opened
+        in read-binary mode.
+
+        Passing a URL is deprecated.  Please open the URL
+        for reading and pass the result to Pillow, e.g. with
+        ``np.array(PIL.Image.open(urllib.request.urlopen(url)))``.
+    format : str, optional
+        The image file format assumed for reading the data.  The image is
+        loaded as a PNG file if *format* is set to "png", if *fname* is a path
+        or opened file with a ".png" extension, or if it is a URL.  In all
+        other cases, *format* is ignored and the format is auto-detected by
+        `PIL.Image.open`.
+
+    Returns
+    -------
+    `numpy.array`
+        The image data. The returned array has shape
+
+        - (M, N) for grayscale images.
+        - (M, N, 3) for RGB images.
+        - (M, N, 4) for RGBA images.
+
+        PNG images are returned as float arrays (0-1).  All other formats are
+        returned as int arrays, with a bit depth determined by the file's
+        contents.
+    """
+    # hide imports to speed initial import on systems with slow linkers
+    from urllib import parse
+
+    if format is None:
+        if isinstance(fname, str):
+            parsed = parse.urlparse(fname)
+            # If the string is a URL (Windows paths appear as if they have a
+            # length-1 scheme), assume png.
+            if len(parsed.scheme) > 1:
+                ext = 'png'
+            else:
+                ext = Path(fname).suffix.lower()[1:]
+        elif hasattr(fname, 'geturl'):  # Returned by urlopen().
+            # We could try to parse the url's path and use the extension, but
+            # returning png is consistent with the block above.  Note that this
+            # if clause has to come before checking for fname.name as
+            # urlopen("file:///...") also has a name attribute (with the fixed
+            # value "<urllib response>").
+            ext = 'png'
+        elif hasattr(fname, 'name'):
+            ext = Path(fname.name).suffix.lower()[1:]
+        else:
+            ext = 'png'
+    else:
+        ext = format
+    img_open = (
+        PIL.PngImagePlugin.PngImageFile if ext == 'png' else PIL.Image.open)
+    if isinstance(fname, str) and len(parse.urlparse(fname).scheme) > 1:
+        # Pillow doesn't handle URLs directly.
+        raise ValueError(
+            "Please open the URL for reading and pass the "
+            "result to Pillow, e.g. with "
+            "``np.array(PIL.Image.open(urllib.request.urlopen(url)))``."
+            )
+    with img_open(fname) as image:
+        return (_pil_png_to_float_array(image)
+                if isinstance(image, PIL.PngImagePlugin.PngImageFile) else
+                pil_to_array(image))
+
+
+def imsave(fname, arr, vmin=None, vmax=None, cmap=None, format=None,
+           origin=None, dpi=100, *, metadata=None, pil_kwargs=None):
+    """
+    Colormap and save an array as an image file.
+
+    RGB(A) images are passed through.  Single channel images will be
+    colormapped according to *cmap* and *norm*.
+
+    .. note::
+
+       If you want to save a single channel image as gray scale please use an
+       image I/O library (such as pillow, tifffile, or imageio) directly.
+
+    Parameters
+    ----------
+    fname : str or path-like or file-like
+        A path or a file-like object to store the image in.
+        If *format* is not set, then the output format is inferred from the
+        extension of *fname*, if any, and from :rc:`savefig.format` otherwise.
+        If *format* is set, it determines the output format.
+    arr : array-like
+        The image data. Accepts NumPy arrays or sequences
+        (e.g., lists or tuples). The shape can be one of
+        MxN (luminance), MxNx3 (RGB) or MxNx4 (RGBA).
+    vmin, vmax : float, optional
+        *vmin* and *vmax* set the color scaling for the image by fixing the
+        values that map to the colormap color limits. If either *vmin*
+        or *vmax* is None, that limit is determined from the *arr*
+        min/max value.
+    cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
+        A Colormap instance or registered colormap name. The colormap
+        maps scalar data to colors. It is ignored for RGB(A) data.
+    format : str, optional
+        The file format, e.g. 'png', 'pdf', 'svg', ...  The behavior when this
+        is unset is documented under *fname*.
+    origin : {'upper', 'lower'}, default: :rc:`image.origin`
+        Indicates whether the ``(0, 0)`` index of the array is in the upper
+        left or lower left corner of the Axes.
+    dpi : float
+        The DPI to store in the metadata of the file.  This does not affect the
+        resolution of the output image.  Depending on file format, this may be
+        rounded to the nearest integer.
+    metadata : dict, optional
+        Metadata in the image file.  The supported keys depend on the output
+        format, see the documentation of the respective backends for more
+        information.
+        Currently only supported for "png", "pdf", "ps", "eps", and "svg".
+    pil_kwargs : dict, optional
+        Keyword arguments passed to `PIL.Image.Image.save`.  If the 'pnginfo'
+        key is present, it completely overrides *metadata*, including the
+        default 'Software' key.
+    """
+    from matplotlib.figure import Figure
+
+    # Normalizing input (e.g., list or tuples) to NumPy array if needed
+    arr = np.asanyarray(arr)
+
+    if isinstance(fname, os.PathLike):
+        fname = os.fspath(fname)
+    if format is None:
+        format = (Path(fname).suffix[1:] if isinstance(fname, str)
+                  else mpl.rcParams["savefig.format"]).lower()
+    if format in ["pdf", "ps", "eps", "svg"]:
+        # Vector formats that are not handled by PIL.
+        if pil_kwargs is not None:
+            raise ValueError(
+                f"Cannot use 'pil_kwargs' when saving to {format}")
+        fig = Figure(dpi=dpi, frameon=False)
+        fig.figimage(arr, cmap=cmap, vmin=vmin, vmax=vmax, origin=origin,
+                     resize=True)
+        fig.savefig(fname, dpi=dpi, format=format, transparent=True,
+                    metadata=metadata)
+    else:
+        # Don't bother creating an image; this avoids rounding errors on the
+        # size when dividing and then multiplying by dpi.
+        if origin is None:
+            origin = mpl.rcParams["image.origin"]
+        else:
+            _api.check_in_list(('upper', 'lower'), origin=origin)
+        if origin == "lower":
+            arr = arr[::-1]
+        if (isinstance(arr, memoryview) and arr.format == "B"
+                and arr.ndim == 3 and arr.shape[-1] == 4):
+            # Such an ``arr`` would also be handled fine by sm.to_rgba below
+            # (after casting with asarray), but it is useful to special-case it
+            # because that's what backend_agg passes, and can be in fact used
+            # as is, saving a few operations.
+            rgba = arr
+        else:
+            sm = mcolorizer.Colorizer(cmap=cmap)
+            sm.set_clim(vmin, vmax)
+            rgba = sm.to_rgba(arr, bytes=True)
+        if pil_kwargs is None:
+            pil_kwargs = {}
+        else:
+            # we modify this below, so make a copy (don't modify caller's dict)
+            pil_kwargs = pil_kwargs.copy()
+        pil_shape = (rgba.shape[1], rgba.shape[0])
+        rgba = np.require(rgba, requirements='C')
+        image = PIL.Image.frombuffer(
+            "RGBA", pil_shape, rgba, "raw", "RGBA", 0, 1)
+        if format == "png":
+            # Only use the metadata kwarg if pnginfo is not set, because the
+            # semantics of duplicate keys in pnginfo is unclear.
+            if "pnginfo" in pil_kwargs:
+                if metadata:
+                    _api.warn_external("'metadata' is overridden by the "
+                                       "'pnginfo' entry in 'pil_kwargs'.")
+            else:
+                metadata = {
+                    "Software": (f"Matplotlib version{mpl.__version__}, "
+                                 f"https://matplotlib.org/"),
+                    **(metadata if metadata is not None else {}),
+                }
+                pil_kwargs["pnginfo"] = pnginfo = PIL.PngImagePlugin.PngInfo()
+                for k, v in metadata.items():
+                    if v is not None:
+                        pnginfo.add_text(k, v)
+        elif metadata is not None:
+            raise ValueError(f"metadata not supported for format {format!r}")
+        if format in ["jpg", "jpeg"]:
+            format = "jpeg"  # Pillow doesn't recognize "jpg".
+            facecolor = mpl.rcParams["savefig.facecolor"]
+            if cbook._str_equal(facecolor, "auto"):
+                facecolor = mpl.rcParams["figure.facecolor"]
+            color = tuple(int(x * 255) for x in mcolors.to_rgb(facecolor))
+            background = PIL.Image.new("RGB", pil_shape, color)
+            background.paste(image, image)
+            image = background
+        pil_kwargs.setdefault("format", format)
+        pil_kwargs.setdefault("dpi", (dpi, dpi))
+        image.save(fname, **pil_kwargs)
+
+
+def pil_to_array(pilImage):
+    """
+    Load a `PIL image`_ and return it as a numpy int array.
+
+    .. _PIL image: https://pillow.readthedocs.io/en/latest/reference/Image.html
+
+    Returns
+    -------
+    numpy.array
+
+        The array shape depends on the image type:
+
+        - (M, N) for grayscale images.
+        - (M, N, 3) for RGB images.
+        - (M, N, 4) for RGBA images.
+    """
+    if pilImage.mode in ['RGBA', 'RGBX', 'RGB', 'L']:
+        # return MxNx4 RGBA, MxNx3 RBA, or MxN luminance array
+        return np.asarray(pilImage)
+    elif pilImage.mode.startswith('I;16'):
+        # return MxN luminance array of uint16
+        raw = pilImage.tobytes('raw', pilImage.mode)
+        if pilImage.mode.endswith('B'):
+            x = np.frombuffer(raw, '>u2')
+        else:
+            x = np.frombuffer(raw, '<u2')
+        return x.reshape(pilImage.size[::-1]).astype('=u2')
+    else:  # try to convert to an rgba image
+        try:
+            pilImage = pilImage.convert('RGBA')
+        except ValueError as err:
+            raise RuntimeError('Unknown image mode') from err
+        return np.asarray(pilImage)  # return MxNx4 RGBA array
+
+
+def _pil_png_to_float_array(pil_png):
+    """Convert a PIL `PNGImageFile` to a 0-1 float array."""
+    # Unlike pil_to_array this converts to 0-1 float32s for backcompat with the
+    # old libpng-based loader.
+    # The supported rawmodes are from PIL.PngImagePlugin._MODES.  When
+    # mode == "RGB(A)", the 16-bit raw data has already been coarsened to 8-bit
+    # by Pillow.
+    mode = pil_png.mode
+    rawmode = pil_png.png.im_rawmode
+    if rawmode == "1":  # Grayscale.
+        return np.asarray(pil_png, np.float32)
+    if rawmode == "L;2":  # Grayscale.
+        return np.divide(pil_png, 2**2 - 1, dtype=np.float32)
+    if rawmode == "L;4":  # Grayscale.
+        return np.divide(pil_png, 2**4 - 1, dtype=np.float32)
+    if rawmode == "L":  # Grayscale.
+        return np.divide(pil_png, 2**8 - 1, dtype=np.float32)
+    if rawmode == "I;16B":  # Grayscale.
+        return np.divide(pil_png, 2**16 - 1, dtype=np.float32)
+    if mode == "RGB":  # RGB.
+        return np.divide(pil_png, 2**8 - 1, dtype=np.float32)
+    if mode == "P":  # Palette.
+        return np.divide(pil_png.convert("RGBA"), 2**8 - 1, dtype=np.float32)
+    if mode == "LA":  # Grayscale + alpha.
+        return np.divide(pil_png.convert("RGBA"), 2**8 - 1, dtype=np.float32)
+    if mode == "RGBA":  # RGBA.
+        return np.divide(pil_png, 2**8 - 1, dtype=np.float32)
+    raise ValueError(f"Unknown PIL rawmode: {rawmode}")
+
+
+def thumbnail(infile, thumbfile, scale=0.1, interpolation='bilinear',
+              preview=False):
+    """
+    Make a thumbnail of image in *infile* with output filename *thumbfile*.
+
+    See :doc:`/gallery/misc/image_thumbnail_sgskip`.
+
+    Parameters
+    ----------
+    infile : str or file-like
+        The image file. Matplotlib relies on Pillow_ for image reading, and
+        thus supports a wide range of file formats, including PNG, JPG, TIFF
+        and others.
+
+        .. _Pillow: https://python-pillow.github.io
+
+    thumbfile : str or file-like
+        The thumbnail filename.
+
+    scale : float, default: 0.1
+        The scale factor for the thumbnail.
+
+    interpolation : str, default: 'bilinear'
+        The interpolation scheme used in the resampling. See the
+        *interpolation* parameter of `~.Axes.imshow` for possible values.
+
+    preview : bool, default: False
+        If True, the default backend (presumably a user interface
+        backend) will be used which will cause a figure to be raised if
+        `~matplotlib.pyplot.show` is called.  If it is False, the figure is
+        created using `.FigureCanvasBase` and the drawing backend is selected
+        as `.Figure.savefig` would normally do.
+
+    Returns
+    -------
+    `.Figure`
+        The figure instance containing the thumbnail.
+    """
+
+    im = imread(infile)
+    rows, cols, depth = im.shape
+
+    # This doesn't really matter (it cancels in the end) but the API needs it.
+    dpi = 100
+
+    height = rows / dpi * scale
+    width = cols / dpi * scale
+
+    if preview:
+        # Let the UI backend do everything.
+        import matplotlib.pyplot as plt
+        fig = plt.figure(figsize=(width, height), dpi=dpi)
+    else:
+        from matplotlib.figure import Figure
+        fig = Figure(figsize=(width, height), dpi=dpi)
+        FigureCanvasBase(fig)
+
+    ax = fig.add_axes([0, 0, 1, 1], aspect='auto',
+                      frameon=False, xticks=[], yticks=[])
+    ax.imshow(im, aspect='auto', resample=True, interpolation=interpolation)
+    fig.savefig(thumbfile, dpi=dpi)
+    return fig

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/image.pyi

@@ -0,0 +1,215 @@
+from collections.abc import Callable, Sequence
+import os
+import pathlib
+from typing import Any, BinaryIO, Literal
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+import PIL.Image
+
+from matplotlib.axes import Axes
+from matplotlib import colorizer
+from matplotlib.backend_bases import RendererBase, MouseEvent
+from matplotlib.colorizer import Colorizer
+from matplotlib.colors import Colormap, Normalize
+from matplotlib.figure import Figure
+from matplotlib.transforms import Affine2D, BboxBase, Bbox, Transform
+
+#
+# These names are re-exported from matplotlib._image.
+#
+
+BESSEL: int
+BICUBIC: int
+BILINEAR: int
+BLACKMAN: int
+CATROM: int
+GAUSSIAN: int
+HAMMING: int
+HANNING: int
+HERMITE: int
+KAISER: int
+LANCZOS: int
+MITCHELL: int
+NEAREST: int
+QUADRIC: int
+SINC: int
+SPLINE16: int
+SPLINE36: int
+
+def resample(
+    input_array: NDArray[np.float32] | NDArray[np.float64] | NDArray[np.int8],
+    output_array: NDArray[np.float32] | NDArray[np.float64] | NDArray[np.int8],
+    transform: Transform,
+    interpolation: int = ...,
+    resample: bool = ...,
+    alpha: float = ...,
+    norm: bool = ...,
+    radius: float = ...,
+) -> None: ...
+
+#
+# END names re-exported from matplotlib._image.
+#
+
+interpolations_names: set[str]
+
+def composite_images(
+    images: Sequence[_ImageBase], renderer: RendererBase, magnification: float = ...
+) -> tuple[np.ndarray, float, float]: ...
+
+class _ImageBase(colorizer.ColorizingArtist):
+    zorder: float
+    origin: Literal["upper", "lower"]
+    axes: Axes
+    def __init__(
+        self,
+        ax: Axes,
+        cmap: str | Colormap | None = ...,
+        norm: str | Normalize | None = ...,
+        colorizer: Colorizer | None = ...,
+        interpolation: str | None = ...,
+        origin: Literal["upper", "lower"] | None = ...,
+        filternorm: bool = ...,
+        filterrad: float = ...,
+        resample: bool | None = ...,
+        *,
+        interpolation_stage: Literal["data", "rgba", "auto"] | None = ...,
+        **kwargs
+    ) -> None: ...
+    def get_size(self) -> tuple[int, int]: ...
+    def set_alpha(self, alpha: float | ArrayLike | None) -> None: ...
+    def changed(self) -> None: ...
+    def make_image(
+        self, renderer: RendererBase, magnification: float = ..., unsampled: bool = ...
+    ) -> tuple[np.ndarray, float, float, Affine2D]: ...
+    def draw(self, renderer: RendererBase) -> None: ...
+    def write_png(self, fname: str | pathlib.Path | BinaryIO) -> None: ...
+    def set_data(self, A: ArrayLike | None) -> None: ...
+    def set_array(self, A: ArrayLike | None) -> None: ...
+    def get_shape(self) -> tuple[int, int, int]: ...
+    def get_interpolation(self) -> str: ...
+    def set_interpolation(self, s: str | None) -> None: ...
+    def get_interpolation_stage(self) -> Literal["data", "rgba", "auto"]: ...
+    def set_interpolation_stage(self, s: Literal["data", "rgba", "auto"]) -> None: ...
+    def can_composite(self) -> bool: ...
+    def set_resample(self, v: bool | None) -> None: ...
+    def get_resample(self) -> bool: ...
+    def set_filternorm(self, filternorm: bool) -> None: ...
+    def get_filternorm(self) -> bool: ...
+    def set_filterrad(self, filterrad: float) -> None: ...
+    def get_filterrad(self) -> float: ...
+
+class AxesImage(_ImageBase):
+    def __init__(
+        self,
+        ax: Axes,
+        *,
+        cmap: str | Colormap | None = ...,
+        norm: str | Normalize | None = ...,
+        colorizer: Colorizer | None = ...,
+        interpolation: str | None = ...,
+        origin: Literal["upper", "lower"] | None = ...,
+        extent: tuple[float, float, float, float] | None = ...,
+        filternorm: bool = ...,
+        filterrad: float = ...,
+        resample: bool = ...,
+        interpolation_stage: Literal["data", "rgba", "auto"] | None = ...,
+        **kwargs
+    ) -> None: ...
+    def get_window_extent(self, renderer: RendererBase | None = ...) -> Bbox: ...
+    def make_image(
+        self, renderer: RendererBase, magnification: float = ..., unsampled: bool = ...
+    ) -> tuple[np.ndarray, float, float, Affine2D]: ...
+    def set_extent(
+        self, extent: tuple[float, float, float, float], **kwargs
+    ) -> None: ...
+    def get_extent(self) -> tuple[float, float, float, float]: ...
+    def get_cursor_data(self, event: MouseEvent) -> None | float: ...
+
+class NonUniformImage(AxesImage):
+    mouseover: bool
+    def __init__(
+        self, ax: Axes, *, interpolation: Literal["nearest", "bilinear"] = ..., **kwargs
+    ) -> None: ...
+    def set_data(self, x: ArrayLike, y: ArrayLike, A: ArrayLike) -> None: ...  # type: ignore[override]
+    # more limited interpolation available here than base class
+    def set_interpolation(self, s: Literal["nearest", "bilinear"]) -> None: ...  # type: ignore[override]
+
+class PcolorImage(AxesImage):
+    def __init__(
+        self,
+        ax: Axes,
+        x: ArrayLike | None = ...,
+        y: ArrayLike | None = ...,
+        A: ArrayLike | None = ...,
+        *,
+        cmap: str | Colormap | None = ...,
+        norm: str | Normalize | None = ...,
+        colorizer: Colorizer | None = ...,
+        **kwargs
+    ) -> None: ...
+    def set_data(self, x: ArrayLike, y: ArrayLike, A: ArrayLike) -> None: ...  # type: ignore[override]
+
+class FigureImage(_ImageBase):
+    zorder: float
+    figure: Figure
+    ox: float
+    oy: float
+    magnification: float
+    def __init__(
+        self,
+        fig: Figure,
+        *,
+        cmap: str | Colormap | None = ...,
+        norm: str | Normalize | None = ...,
+        colorizer: Colorizer | None = ...,
+        offsetx: int = ...,
+        offsety: int = ...,
+        origin: Literal["upper", "lower"] | None = ...,
+        **kwargs
+    ) -> None: ...
+    def get_extent(self) -> tuple[float, float, float, float]: ...
+
+class BboxImage(_ImageBase):
+    bbox: BboxBase
+    def __init__(
+        self,
+        bbox: BboxBase | Callable[[RendererBase | None], Bbox],
+        *,
+        cmap: str | Colormap | None = ...,
+        norm: str | Normalize | None = ...,
+        colorizer: Colorizer | None = ...,
+        interpolation: str | None = ...,
+        origin: Literal["upper", "lower"] | None = ...,
+        filternorm: bool = ...,
+        filterrad: float = ...,
+        resample: bool = ...,
+        **kwargs
+    ) -> None: ...
+    def get_window_extent(self, renderer: RendererBase | None = ...) -> Bbox: ...
+
+def imread(
+    fname: str | pathlib.Path | BinaryIO, format: str | None = ...
+) -> np.ndarray: ...
+def imsave(
+    fname: str | os.PathLike | BinaryIO,
+    arr: ArrayLike,
+    vmin: float | None = ...,
+    vmax: float | None = ...,
+    cmap: str | Colormap | None = ...,
+    format: str | None = ...,
+    origin: Literal["upper", "lower"] | None = ...,
+    dpi: float = ...,
+    *,
+    metadata: dict[str, str] | None = ...,
+    pil_kwargs: dict[str, Any] | None = ...
+) -> None: ...
+def pil_to_array(pilImage: PIL.Image.Image) -> np.ndarray: ...
+def thumbnail(
+    infile: str | BinaryIO,
+    thumbfile: str | BinaryIO,
+    scale: float = ...,
+    interpolation: str = ...,
+    preview: bool = ...,
+) -> Figure: ...

outputs/audit_venv/lib/python3.11/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]

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/inset.pyi

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

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/layout_engine.py

@@ -0,0 +1,309 @@
+"""
+Classes to layout elements in a `.Figure`.
+
+Figures have a ``layout_engine`` property that holds a subclass of
+`~.LayoutEngine` defined here (or *None* for no layout).  At draw time
+``figure.get_layout_engine().execute()`` is called, the goal of which is
+usually to rearrange Axes on the figure to produce a pleasing layout. This is
+like a ``draw`` callback but with two differences.  First, when printing we
+disable the layout engine for the final draw. Second, it is useful to know the
+layout engine while the figure is being created.  In particular, colorbars are
+made differently with different layout engines (for historical reasons).
+
+Matplotlib has two built-in layout engines:
+
+- `.TightLayoutEngine` was the first layout engine added to Matplotlib.
+  See also :ref:`tight_layout_guide`.
+- `.ConstrainedLayoutEngine` is more modern and generally gives better results.
+  See also :ref:`constrainedlayout_guide`.
+
+Third parties can create their own layout engine by subclassing `.LayoutEngine`.
+"""
+
+from contextlib import nullcontext
+
+import matplotlib as mpl
+
+from matplotlib._constrained_layout import do_constrained_layout
+from matplotlib._tight_layout import (get_subplotspec_list,
+                                      get_tight_layout_figure)
+
+
+class LayoutEngine:
+    """
+    Base class for Matplotlib layout engines.
+
+    A layout engine can be passed to a figure at instantiation or at any time
+    with `~.figure.Figure.set_layout_engine`.  Once attached to a figure, the
+    layout engine ``execute`` function is called at draw time by
+    `~.figure.Figure.draw`, providing a special draw-time hook.
+
+    .. note::
+
+       However, note that layout engines affect the creation of colorbars, so
+       `~.figure.Figure.set_layout_engine` should be called before any
+       colorbars are created.
+
+    Currently, there are two properties of `LayoutEngine` classes that are
+    consulted while manipulating the figure:
+
+    - ``engine.colorbar_gridspec`` tells `.Figure.colorbar` whether to make the
+       axes using the gridspec method (see `.colorbar.make_axes_gridspec`) or
+       not (see `.colorbar.make_axes`);
+    - ``engine.adjust_compatible`` stops `.Figure.subplots_adjust` from being
+        run if it is not compatible with the layout engine.
+
+    To implement a custom `LayoutEngine`:
+
+    1. override ``_adjust_compatible`` and ``_colorbar_gridspec``
+    2. override `LayoutEngine.set` to update *self._params*
+    3. override `LayoutEngine.execute` with your implementation
+
+    """
+    # override these in subclass
+    _adjust_compatible = None
+    _colorbar_gridspec = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._params = {}
+
+    def set(self, **kwargs):
+        """
+        Set the parameters for the layout engine.
+        """
+        raise NotImplementedError
+
+    @property
+    def colorbar_gridspec(self):
+        """
+        Return a boolean if the layout engine creates colorbars using a
+        gridspec.
+        """
+        if self._colorbar_gridspec is None:
+            raise NotImplementedError
+        return self._colorbar_gridspec
+
+    @property
+    def adjust_compatible(self):
+        """
+        Return a boolean if the layout engine is compatible with
+        `~.Figure.subplots_adjust`.
+        """
+        if self._adjust_compatible is None:
+            raise NotImplementedError
+        return self._adjust_compatible
+
+    def get(self):
+        """
+        Return copy of the parameters for the layout engine.
+        """
+        return dict(self._params)
+
+    def execute(self, fig):
+        """
+        Execute the layout on the figure given by *fig*.
+        """
+        # subclasses must implement this.
+        raise NotImplementedError
+
+
+class PlaceHolderLayoutEngine(LayoutEngine):
+    """
+    This layout engine does not adjust the figure layout at all.
+
+    The purpose of this `.LayoutEngine` is to act as a placeholder when the user removes
+    a layout engine to ensure an incompatible `.LayoutEngine` cannot be set later.
+
+    Parameters
+    ----------
+    adjust_compatible, colorbar_gridspec : bool
+        Allow the PlaceHolderLayoutEngine to mirror the behavior of whatever
+        layout engine it is replacing.
+
+    """
+    def __init__(self, adjust_compatible, colorbar_gridspec, **kwargs):
+        self._adjust_compatible = adjust_compatible
+        self._colorbar_gridspec = colorbar_gridspec
+        super().__init__(**kwargs)
+
+    def execute(self, fig):
+        """
+        Do nothing.
+        """
+        return
+
+
+class TightLayoutEngine(LayoutEngine):
+    """
+    Implements the ``tight_layout`` geometry management.  See
+    :ref:`tight_layout_guide` for details.
+    """
+    _adjust_compatible = True
+    _colorbar_gridspec = True
+
+    def __init__(self, *, pad=1.08, h_pad=None, w_pad=None,
+                 rect=(0, 0, 1, 1), **kwargs):
+        """
+        Initialize tight_layout engine.
+
+        Parameters
+        ----------
+        pad : float, default: 1.08
+            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: (0, 0, 1, 1).
+            rectangle in normalized figure coordinates that the subplots
+            (including labels) will fit into.
+        """
+        super().__init__(**kwargs)
+        for td in ['pad', 'h_pad', 'w_pad', 'rect']:
+            # initialize these in case None is passed in above:
+            self._params[td] = None
+        self.set(pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect)
+
+    def execute(self, fig):
+        """
+        Execute tight_layout.
+
+        This decides the subplot parameters given the padding that
+        will allow the Axes labels to not be covered by other labels
+        and Axes.
+
+        Parameters
+        ----------
+        fig : `.Figure` to perform layout on.
+
+        See Also
+        --------
+        .figure.Figure.tight_layout
+        .pyplot.tight_layout
+        """
+        info = self._params
+        renderer = fig._get_renderer()
+        with getattr(renderer, "_draw_disabled", nullcontext)():
+            kwargs = get_tight_layout_figure(
+                fig, fig.axes, get_subplotspec_list(fig.axes), renderer,
+                pad=info['pad'], h_pad=info['h_pad'], w_pad=info['w_pad'],
+                rect=info['rect'])
+        if kwargs:
+            fig.subplots_adjust(**kwargs)
+
+    def set(self, *, pad=None, w_pad=None, h_pad=None, rect=None):
+        """
+        Set the pads for tight_layout.
+
+        Parameters
+        ----------
+        pad : float
+            Padding between the figure edge and the edges of subplots, as a
+            fraction of the font size.
+        w_pad, h_pad : float
+            Padding (width/height) between edges of adjacent subplots.
+            Defaults to *pad*.
+        rect : tuple (left, bottom, right, top)
+            rectangle in normalized figure coordinates that the subplots
+            (including labels) will fit into.
+        """
+        for td in self.set.__kwdefaults__:
+            if locals()[td] is not None:
+                self._params[td] = locals()[td]
+
+
+class ConstrainedLayoutEngine(LayoutEngine):
+    """
+    Implements the ``constrained_layout`` geometry management.  See
+    :ref:`constrainedlayout_guide` for details.
+    """
+
+    _adjust_compatible = False
+    _colorbar_gridspec = False
+
+    def __init__(self, *, h_pad=None, w_pad=None,
+                 hspace=None, wspace=None, rect=(0, 0, 1, 1),
+                 compress=False, **kwargs):
+        """
+        Initialize ``constrained_layout`` settings.
+
+        Parameters
+        ----------
+        h_pad, w_pad : float
+            Padding around the Axes elements in inches.
+            Default to :rc:`figure.constrained_layout.h_pad` and
+            :rc:`figure.constrained_layout.w_pad`.
+        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.
+            Default to :rc:`figure.constrained_layout.hspace` and
+            :rc:`figure.constrained_layout.wspace`.
+        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).  See :ref:`compressed_layout`.
+        """
+        super().__init__(**kwargs)
+        # set the defaults:
+        self.set(w_pad=mpl.rcParams['figure.constrained_layout.w_pad'],
+                 h_pad=mpl.rcParams['figure.constrained_layout.h_pad'],
+                 wspace=mpl.rcParams['figure.constrained_layout.wspace'],
+                 hspace=mpl.rcParams['figure.constrained_layout.hspace'],
+                 rect=(0, 0, 1, 1))
+        # set anything that was passed in (None will be ignored):
+        self.set(w_pad=w_pad, h_pad=h_pad, wspace=wspace, hspace=hspace,
+                 rect=rect)
+        self._compress = compress
+
+    def execute(self, fig):
+        """
+        Perform constrained_layout and move and resize Axes accordingly.
+
+        Parameters
+        ----------
+        fig : `.Figure` to perform layout on.
+        """
+        width, height = fig.get_size_inches()
+        # pads are relative to the current state of the figure...
+        w_pad = self._params['w_pad'] / width
+        h_pad = self._params['h_pad'] / height
+
+        return do_constrained_layout(fig, w_pad=w_pad, h_pad=h_pad,
+                                     wspace=self._params['wspace'],
+                                     hspace=self._params['hspace'],
+                                     rect=self._params['rect'],
+                                     compress=self._compress)
+
+    def set(self, *, h_pad=None, w_pad=None,
+            hspace=None, wspace=None, rect=None):
+        """
+        Set the pads for constrained_layout.
+
+        Parameters
+        ----------
+        h_pad, w_pad : float
+            Padding around the Axes elements in inches.
+            Default to :rc:`figure.constrained_layout.h_pad` and
+            :rc:`figure.constrained_layout.w_pad`.
+        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.
+            Default to :rc:`figure.constrained_layout.hspace` and
+            :rc:`figure.constrained_layout.wspace`.
+        rect : tuple of 4 floats
+            Rectangle in figure coordinates to perform constrained layout in
+            (left, bottom, width, height), each from 0-1.
+        """
+        for td in self.set.__kwdefaults__:
+            if locals()[td] is not None:
+                self._params[td] = locals()[td]

outputs/audit_venv/lib/python3.11/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: ...

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/legend.py

@@ -0,0 +1,1371 @@
+"""
+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)]
+
+        handles = list(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

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/legend.pyi

@@ -0,0 +1,152 @@
+from matplotlib.axes import Axes
+from matplotlib.artist import Artist
+from matplotlib.backend_bases import MouseEvent
+from matplotlib.figure import Figure
+from matplotlib.font_manager import FontProperties
+from matplotlib.legend_handler import HandlerBase
+from matplotlib.lines import Line2D
+from matplotlib.offsetbox import (
+    DraggableOffsetBox,
+)
+from matplotlib.patches import FancyBboxPatch, Patch, Rectangle
+from matplotlib.text import Text
+from matplotlib.transforms import (
+    BboxBase,
+    Transform,
+)
+
+
+import pathlib
+from collections.abc import Iterable
+from typing import Any, Literal, overload
+from .typing import ColorType
+
+class DraggableLegend(DraggableOffsetBox):
+    legend: Legend
+    def __init__(
+        self, legend: Legend, use_blit: bool = ..., update: Literal["loc", "bbox"] = ...
+    ) -> None: ...
+    def finalize_offset(self) -> None: ...
+
+class Legend(Artist):
+    codes: dict[str, int]
+    zorder: float
+    prop: FontProperties
+    texts: list[Text]
+    legend_handles: list[Artist | None]
+    numpoints: int
+    markerscale: float
+    scatterpoints: int
+    borderpad: float
+    labelspacing: float
+    handlelength: float
+    handleheight: float
+    handletextpad: float
+    borderaxespad: float
+    columnspacing: float
+    shadow: bool
+    isaxes: bool
+    axes: Axes
+    parent: Axes | Figure
+    legendPatch: FancyBboxPatch
+    def __init__(
+        self,
+        parent: Axes | Figure,
+        handles: Iterable[Artist | tuple[Artist, ...]],
+        labels: Iterable[str],
+        *,
+        loc: str | tuple[float, float] | int | None = ...,
+        numpoints: int | None = ...,
+        markerscale: float | None = ...,
+        markerfirst: bool = ...,
+        reverse: bool = ...,
+        scatterpoints: int | None = ...,
+        scatteryoffsets: Iterable[float] | None = ...,
+        prop: FontProperties | dict[str, Any] | None = ...,
+        fontsize: float | str | None = ...,
+        labelcolor: ColorType
+        | Iterable[ColorType]
+        | Literal["linecolor", "markerfacecolor", "mfc", "markeredgecolor", "mec"]
+        | None = ...,
+        borderpad: float | None = ...,
+        labelspacing: float | None = ...,
+        handlelength: float | None = ...,
+        handleheight: float | None = ...,
+        handletextpad: float | None = ...,
+        borderaxespad: float | None = ...,
+        columnspacing: float | None = ...,
+        ncols: int = ...,
+        mode: Literal["expand"] | None = ...,
+        fancybox: bool | None = ...,
+        shadow: bool | dict[str, Any] | None = ...,
+        title: str | None = ...,
+        title_fontsize: float | None = ...,
+        framealpha: float | None = ...,
+        edgecolor: Literal["inherit"] | ColorType | None = ...,
+        facecolor: Literal["inherit"] | ColorType | None = ...,
+        bbox_to_anchor: BboxBase
+        | tuple[float, float]
+        | tuple[float, float, float, float]
+        | None = ...,
+        bbox_transform: Transform | None = ...,
+        frameon: bool | None = ...,
+        handler_map: dict[Artist | type, HandlerBase] | None = ...,
+        title_fontproperties: FontProperties | dict[str, Any] | None = ...,
+        alignment: Literal["center", "left", "right"] = ...,
+        ncol: int = ...,
+        draggable: bool = ...
+    ) -> None: ...
+    def contains(self, mouseevent: MouseEvent) -> tuple[bool, dict[Any, Any]]: ...
+    def set_ncols(self, ncols: int) -> None: ...
+    @classmethod
+    def get_default_handler_map(cls) -> dict[type, HandlerBase]: ...
+    @classmethod
+    def set_default_handler_map(cls, handler_map: dict[type, HandlerBase]) -> None: ...
+    @classmethod
+    def update_default_handler_map(
+        cls, handler_map: dict[type, HandlerBase]
+    ) -> None: ...
+    def get_legend_handler_map(self) -> dict[type, HandlerBase]: ...
+    @staticmethod
+    def get_legend_handler(
+        legend_handler_map: dict[type, HandlerBase], orig_handle: Any
+    ) -> HandlerBase | None: ...
+    def get_children(self) -> list[Artist]: ...
+    def get_frame(self) -> Rectangle: ...
+    def get_lines(self) -> list[Line2D]: ...
+    def get_patches(self) -> list[Patch]: ...
+    def get_texts(self) -> list[Text]: ...
+    def set_alignment(self, alignment: Literal["center", "left", "right"]) -> None: ...
+    def get_alignment(self) -> Literal["center", "left", "right"]: ...
+    def set_loc(self, loc: str | tuple[float, float] | int | None = ...) -> None: ...
+    def set_title(
+        self, title: str, prop: FontProperties | str | pathlib.Path | None = ...
+    ) -> None: ...
+    def get_title(self) -> Text: ...
+    def get_frame_on(self) -> bool: ...
+    def set_frame_on(self, b: bool) -> None: ...
+    draw_frame = set_frame_on
+    def get_bbox_to_anchor(self) -> BboxBase: ...
+    def set_bbox_to_anchor(
+        self,
+        bbox: BboxBase
+        | tuple[float, float]
+        | tuple[float, float, float, float]
+        | None,
+        transform: Transform | None = ...
+    ) -> None: ...
+    @overload
+    def set_draggable(
+        self,
+        state: Literal[True],
+        use_blit: bool = ...,
+        update: Literal["loc", "bbox"] = ...,
+    ) -> DraggableLegend: ...
+    @overload
+    def set_draggable(
+        self,
+        state: Literal[False],
+        use_blit: bool = ...,
+        update: Literal["loc", "bbox"] = ...,
+    ) -> None: ...
+    def get_draggable(self) -> bool: ...

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/legend_handler.py

@@ -0,0 +1,812 @@
+"""
+Default legend handlers.
+
+.. important::
+
+    This is a low-level legend API, which most end users do not need.
+
+    We recommend that you are familiar with the :ref:`legend guide
+    <legend_guide>` before reading this documentation.
+
+Legend handlers are expected to be a callable object with a following
+signature::
+
+    legend_handler(legend, orig_handle, fontsize, handlebox)
+
+Where *legend* is the legend itself, *orig_handle* is the original
+plot, *fontsize* is the fontsize in pixels, and *handlebox* is an
+`.OffsetBox` instance. Within the call, you should create relevant
+artists (using relevant properties from the *legend* and/or
+*orig_handle*) and add them into the *handlebox*. The artists need to
+be scaled according to the *fontsize* (note that the size is in pixels,
+i.e., this is dpi-scaled value).
+
+This module includes definition of several legend handler classes
+derived from the base class (HandlerBase) with the following method::
+
+    def legend_artist(self, legend, orig_handle, fontsize, handlebox)
+"""
+
+from itertools import cycle
+
+import numpy as np
+
+from matplotlib import cbook
+from matplotlib.lines import Line2D
+from matplotlib.patches import Rectangle
+import matplotlib.collections as mcoll
+
+
+def update_from_first_child(tgt, src):
+    first_child = next(iter(src.get_children()), None)
+    if first_child is not None:
+        tgt.update_from(first_child)
+
+
+class HandlerBase:
+    """
+    A base class for default legend handlers.
+
+    The derived classes are meant to override *create_artists* method, which
+    has the following signature::
+
+      def create_artists(self, legend, orig_handle,
+                         xdescent, ydescent, width, height, fontsize,
+                         trans):
+
+    The overridden method needs to create artists of the given
+    transform that fits in the given dimension (xdescent, ydescent,
+    width, height) that are scaled by fontsize if necessary.
+
+    """
+    def __init__(self, xpad=0., ypad=0., update_func=None):
+        """
+        Parameters
+        ----------
+        xpad : float, optional
+            Padding in x-direction.
+        ypad : float, optional
+            Padding in y-direction.
+        update_func : callable, optional
+            Function for updating the legend handler properties from another
+            legend handler, used by `~HandlerBase.update_prop`.
+        """
+        self._xpad, self._ypad = xpad, ypad
+        self._update_prop_func = update_func
+
+    def _update_prop(self, legend_handle, orig_handle):
+        if self._update_prop_func is None:
+            self._default_update_prop(legend_handle, orig_handle)
+        else:
+            self._update_prop_func(legend_handle, orig_handle)
+
+    def _default_update_prop(self, legend_handle, orig_handle):
+        legend_handle.update_from(orig_handle)
+
+    def update_prop(self, legend_handle, orig_handle, legend):
+
+        self._update_prop(legend_handle, orig_handle)
+
+        legend._set_artist_props(legend_handle)
+        legend_handle.set_clip_box(None)
+        legend_handle.set_clip_path(None)
+
+    def adjust_drawing_area(self, legend, orig_handle,
+                            xdescent, ydescent, width, height, fontsize,
+                            ):
+        xdescent = xdescent - self._xpad * fontsize
+        ydescent = ydescent - self._ypad * fontsize
+        width = width - self._xpad * fontsize
+        height = height - self._ypad * fontsize
+        return xdescent, ydescent, width, height
+
+    def legend_artist(self, legend, orig_handle,
+                      fontsize, handlebox):
+        """
+        Return the artist that this HandlerBase generates for the given
+        original artist/handle.
+
+        Parameters
+        ----------
+        legend : `~matplotlib.legend.Legend`
+            The legend for which these legend artists are being created.
+        orig_handle : :class:`matplotlib.artist.Artist` or similar
+            The object for which these legend artists are being created.
+        fontsize : int
+            The fontsize in pixels. The artists being created should
+            be scaled according to the given fontsize.
+        handlebox : `~matplotlib.offsetbox.OffsetBox`
+            The box which has been created to hold this legend entry's
+            artists. Artists created in the `legend_artist` method must
+            be added to this handlebox inside this method.
+
+        """
+        xdescent, ydescent, width, height = self.adjust_drawing_area(
+                 legend, orig_handle,
+                 handlebox.xdescent, handlebox.ydescent,
+                 handlebox.width, handlebox.height,
+                 fontsize)
+        artists = self.create_artists(legend, orig_handle,
+                                      xdescent, ydescent, width, height,
+                                      fontsize, handlebox.get_transform())
+
+        # create_artists will return a list of artists.
+        for a in artists:
+            handlebox.add_artist(a)
+
+        # we only return the first artist
+        return artists[0]
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize,
+                       trans):
+        """
+        Return the legend artists generated.
+
+        Parameters
+        ----------
+        legend : `~matplotlib.legend.Legend`
+            The legend for which these legend artists are being created.
+        orig_handle : `~matplotlib.artist.Artist` or similar
+            The object for which these legend artists are being created.
+        xdescent, ydescent, width, height : int
+            The rectangle (*xdescent*, *ydescent*, *width*, *height*) that the
+            legend artists being created should fit within.
+        fontsize : int
+            The fontsize in pixels. The legend artists being created should
+            be scaled according to the given fontsize.
+        trans : `~matplotlib.transforms.Transform`
+            The transform that is applied to the legend artists being created.
+            Typically from unit coordinates in the handler box to screen
+            coordinates.
+        """
+        raise NotImplementedError('Derived must override')
+
+
+class HandlerNpoints(HandlerBase):
+    """
+    A legend handler that shows *numpoints* points in the legend entry.
+    """
+
+    def __init__(self, marker_pad=0.3, numpoints=None, **kwargs):
+        """
+        Parameters
+        ----------
+        marker_pad : float
+            Padding between points in legend entry.
+        numpoints : int
+            Number of points to show in legend entry.
+        **kwargs
+            Keyword arguments forwarded to `.HandlerBase`.
+        """
+        super().__init__(**kwargs)
+
+        self._numpoints = numpoints
+        self._marker_pad = marker_pad
+
+    def get_numpoints(self, legend):
+        if self._numpoints is None:
+            return legend.numpoints
+        else:
+            return self._numpoints
+
+    def get_xdata(self, legend, xdescent, ydescent, width, height, fontsize):
+        numpoints = self.get_numpoints(legend)
+        if numpoints > 1:
+            # we put some pad here to compensate the size of the marker
+            pad = self._marker_pad * fontsize
+            xdata = np.linspace(-xdescent + pad,
+                                -xdescent + width - pad,
+                                numpoints)
+            xdata_marker = xdata
+        else:
+            xdata = [-xdescent, -xdescent + width]
+            xdata_marker = [-xdescent + 0.5 * width]
+        return xdata, xdata_marker
+
+
+class HandlerNpointsYoffsets(HandlerNpoints):
+    """
+    A legend handler that shows *numpoints* in the legend, and allows them to
+    be individually offset in the y-direction.
+    """
+
+    def __init__(self, numpoints=None, yoffsets=None, **kwargs):
+        """
+        Parameters
+        ----------
+        numpoints : int
+            Number of points to show in legend entry.
+        yoffsets : array of floats
+            Length *numpoints* list of y offsets for each point in
+            legend entry.
+        **kwargs
+            Keyword arguments forwarded to `.HandlerNpoints`.
+        """
+        super().__init__(numpoints=numpoints, **kwargs)
+        self._yoffsets = yoffsets
+
+    def get_ydata(self, legend, xdescent, ydescent, width, height, fontsize):
+        if self._yoffsets is None:
+            ydata = height * legend._scatteryoffsets
+        else:
+            ydata = height * np.asarray(self._yoffsets)
+
+        return ydata
+
+
+class HandlerLine2DCompound(HandlerNpoints):
+    """
+    Original handler for `.Line2D` instances, that relies on combining
+    a line-only with a marker-only artist.  May be deprecated in the future.
+    """
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize,
+                       trans):
+        # docstring inherited
+        xdata, xdata_marker = self.get_xdata(legend, xdescent, ydescent,
+                                             width, height, fontsize)
+
+        ydata = np.full_like(xdata, ((height - ydescent) / 2))
+        legline = Line2D(xdata, ydata)
+
+        self.update_prop(legline, orig_handle, legend)
+        legline.set_drawstyle('default')
+        legline.set_marker("")
+
+        legline_marker = Line2D(xdata_marker, ydata[:len(xdata_marker)])
+        self.update_prop(legline_marker, orig_handle, legend)
+        legline_marker.set_linestyle('None')
+        if legend.markerscale != 1:
+            newsz = legline_marker.get_markersize() * legend.markerscale
+            legline_marker.set_markersize(newsz)
+        # we don't want to add this to the return list because
+        # the texts and handles are assumed to be in one-to-one
+        # correspondence.
+        legline._legmarker = legline_marker
+
+        legline.set_transform(trans)
+        legline_marker.set_transform(trans)
+
+        return [legline, legline_marker]
+
+
+class HandlerLine2D(HandlerNpoints):
+    """
+    Handler for `.Line2D` instances.
+
+    See Also
+    --------
+    HandlerLine2DCompound : An earlier handler implementation, which used one
+                            artist for the line and another for the marker(s).
+    """
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize,
+                       trans):
+        # docstring inherited
+        xdata, xdata_marker = self.get_xdata(legend, xdescent, ydescent,
+                                             width, height, fontsize)
+
+        markevery = None
+        if self.get_numpoints(legend) == 1:
+            # Special case: one wants a single marker in the center
+            # and a line that extends on both sides. One will use a
+            # 3 points line, but only mark the #1 (i.e. middle) point.
+            xdata = np.linspace(xdata[0], xdata[-1], 3)
+            markevery = [1]
+
+        ydata = np.full_like(xdata, (height - ydescent) / 2)
+        legline = Line2D(xdata, ydata, markevery=markevery)
+
+        self.update_prop(legline, orig_handle, legend)
+
+        if legend.markerscale != 1:
+            newsz = legline.get_markersize() * legend.markerscale
+            legline.set_markersize(newsz)
+
+        legline.set_transform(trans)
+
+        return [legline]
+
+
+class HandlerPatch(HandlerBase):
+    """
+    Handler for `.Patch` instances.
+    """
+
+    def __init__(self, patch_func=None, **kwargs):
+        """
+        Parameters
+        ----------
+        patch_func : callable, optional
+            The function that creates the legend key artist.
+            *patch_func* should have the signature::
+
+                def patch_func(legend=legend, orig_handle=orig_handle,
+                               xdescent=xdescent, ydescent=ydescent,
+                               width=width, height=height, fontsize=fontsize)
+
+            Subsequently, the created artist will have its ``update_prop``
+            method called and the appropriate transform will be applied.
+
+        **kwargs
+            Keyword arguments forwarded to `.HandlerBase`.
+        """
+        super().__init__(**kwargs)
+        self._patch_func = patch_func
+
+    def _create_patch(self, legend, orig_handle,
+                      xdescent, ydescent, width, height, fontsize):
+        if self._patch_func is None:
+            p = Rectangle(xy=(-xdescent, -ydescent),
+                          width=width, height=height)
+        else:
+            p = self._patch_func(legend=legend, orig_handle=orig_handle,
+                                 xdescent=xdescent, ydescent=ydescent,
+                                 width=width, height=height, fontsize=fontsize)
+        return p
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize, trans):
+        # docstring inherited
+        p = self._create_patch(legend, orig_handle,
+                               xdescent, ydescent, width, height, fontsize)
+        self.update_prop(p, orig_handle, legend)
+        p.set_transform(trans)
+        return [p]
+
+
+class HandlerStepPatch(HandlerBase):
+    """
+    Handler for `~.matplotlib.patches.StepPatch` instances.
+    """
+
+    @staticmethod
+    def _create_patch(orig_handle, xdescent, ydescent, width, height):
+        return Rectangle(xy=(-xdescent, -ydescent), width=width,
+                         height=height, color=orig_handle.get_facecolor())
+
+    @staticmethod
+    def _create_line(orig_handle, width, height):
+        # Unfilled StepPatch should show as a line
+        legline = Line2D([0, width], [height/2, height/2],
+                         color=orig_handle.get_edgecolor(),
+                         linestyle=orig_handle.get_linestyle(),
+                         linewidth=orig_handle.get_linewidth(),
+                         )
+
+        # Overwrite manually because patch and line properties don't mix
+        legline.set_drawstyle('default')
+        legline.set_marker("")
+        return legline
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize, trans):
+        # docstring inherited
+        if orig_handle.get_fill() or (orig_handle.get_hatch() is not None):
+            p = self._create_patch(orig_handle, xdescent, ydescent, width,
+                                   height)
+            self.update_prop(p, orig_handle, legend)
+        else:
+            p = self._create_line(orig_handle, width, height)
+        p.set_transform(trans)
+        return [p]
+
+
+class HandlerLineCollection(HandlerLine2D):
+    """
+    Handler for `.LineCollection` instances.
+    """
+    def get_numpoints(self, legend):
+        if self._numpoints is None:
+            return legend.scatterpoints
+        else:
+            return self._numpoints
+
+    def _default_update_prop(self, legend_handle, orig_handle):
+        lw = orig_handle.get_linewidths()[0]
+        dashes = orig_handle._us_linestyles[0]
+        color = orig_handle.get_colors()[0]
+        legend_handle.set_color(color)
+        legend_handle.set_linestyle(dashes)
+        legend_handle.set_linewidth(lw)
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize, trans):
+        # docstring inherited
+        xdata, xdata_marker = self.get_xdata(legend, xdescent, ydescent,
+                                             width, height, fontsize)
+        ydata = np.full_like(xdata, (height - ydescent) / 2)
+        legline = Line2D(xdata, ydata)
+
+        self.update_prop(legline, orig_handle, legend)
+        legline.set_transform(trans)
+
+        return [legline]
+
+
+class HandlerRegularPolyCollection(HandlerNpointsYoffsets):
+    r"""Handler for `.RegularPolyCollection`\s."""
+
+    def __init__(self, yoffsets=None, sizes=None, **kwargs):
+        super().__init__(yoffsets=yoffsets, **kwargs)
+
+        self._sizes = sizes
+
+    def get_numpoints(self, legend):
+        if self._numpoints is None:
+            return legend.scatterpoints
+        else:
+            return self._numpoints
+
+    def get_sizes(self, legend, orig_handle,
+                  xdescent, ydescent, width, height, fontsize):
+        if self._sizes is None:
+            handle_sizes = orig_handle.get_sizes()
+            if not len(handle_sizes):
+                handle_sizes = [1]
+            size_max = max(handle_sizes) * legend.markerscale ** 2
+            size_min = min(handle_sizes) * legend.markerscale ** 2
+
+            numpoints = self.get_numpoints(legend)
+            if numpoints < 4:
+                sizes = [.5 * (size_max + size_min), size_max,
+                         size_min][:numpoints]
+            else:
+                rng = (size_max - size_min)
+                sizes = rng * np.linspace(0, 1, numpoints) + size_min
+        else:
+            sizes = self._sizes
+
+        return sizes
+
+    def update_prop(self, legend_handle, orig_handle, legend):
+
+        self._update_prop(legend_handle, orig_handle)
+
+        legend_handle.set_figure(legend.get_figure(root=False))
+        # legend._set_artist_props(legend_handle)
+        legend_handle.set_clip_box(None)
+        legend_handle.set_clip_path(None)
+
+    def create_collection(self, orig_handle, sizes, offsets, offset_transform):
+        return type(orig_handle)(
+            orig_handle.get_numsides(),
+            rotation=orig_handle.get_rotation(), sizes=sizes,
+            offsets=offsets, offset_transform=offset_transform,
+        )
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize,
+                       trans):
+        # docstring inherited
+        xdata, xdata_marker = self.get_xdata(legend, xdescent, ydescent,
+                                             width, height, fontsize)
+
+        ydata = self.get_ydata(legend, xdescent, ydescent,
+                               width, height, fontsize)
+
+        sizes = self.get_sizes(legend, orig_handle, xdescent, ydescent,
+                               width, height, fontsize)
+
+        p = self.create_collection(
+            orig_handle, sizes,
+            offsets=list(zip(xdata_marker, ydata)), offset_transform=trans)
+
+        self.update_prop(p, orig_handle, legend)
+        p.set_offset_transform(trans)
+        return [p]
+
+
+class HandlerPathCollection(HandlerRegularPolyCollection):
+    r"""Handler for `.PathCollection`\s, which are used by `~.Axes.scatter`."""
+
+    def create_collection(self, orig_handle, sizes, offsets, offset_transform):
+        return type(orig_handle)(
+            [orig_handle.get_paths()[0]], sizes=sizes,
+            offsets=offsets, offset_transform=offset_transform,
+        )
+
+
+class HandlerCircleCollection(HandlerRegularPolyCollection):
+    r"""Handler for `.CircleCollection`\s."""
+
+    def create_collection(self, orig_handle, sizes, offsets, offset_transform):
+        return type(orig_handle)(
+            sizes, offsets=offsets, offset_transform=offset_transform)
+
+
+class HandlerErrorbar(HandlerLine2D):
+    """Handler for Errorbars."""
+
+    def __init__(self, xerr_size=0.5, yerr_size=None,
+                 marker_pad=0.3, numpoints=None, **kwargs):
+
+        self._xerr_size = xerr_size
+        self._yerr_size = yerr_size
+
+        super().__init__(marker_pad=marker_pad, numpoints=numpoints, **kwargs)
+
+    def get_err_size(self, legend, xdescent, ydescent,
+                     width, height, fontsize):
+        xerr_size = self._xerr_size * fontsize
+
+        if self._yerr_size is None:
+            yerr_size = xerr_size
+        else:
+            yerr_size = self._yerr_size * fontsize
+
+        return xerr_size, yerr_size
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize,
+                       trans):
+        # docstring inherited
+        plotlines, caplines, barlinecols = orig_handle
+
+        xdata, xdata_marker = self.get_xdata(legend, xdescent, ydescent,
+                                             width, height, fontsize)
+
+        ydata = np.full_like(xdata, (height - ydescent) / 2)
+        legline = Line2D(xdata, ydata)
+
+        xdata_marker = np.asarray(xdata_marker)
+        ydata_marker = np.asarray(ydata[:len(xdata_marker)])
+
+        xerr_size, yerr_size = self.get_err_size(legend, xdescent, ydescent,
+                                                 width, height, fontsize)
+
+        legline_marker = Line2D(xdata_marker, ydata_marker)
+
+        # when plotlines are None (only errorbars are drawn), we just
+        # make legline invisible.
+        if plotlines is None:
+            legline.set_visible(False)
+            legline_marker.set_visible(False)
+        else:
+            self.update_prop(legline, plotlines, legend)
+
+            legline.set_drawstyle('default')
+            legline.set_marker('none')
+
+            self.update_prop(legline_marker, plotlines, legend)
+            legline_marker.set_linestyle('None')
+
+            if legend.markerscale != 1:
+                newsz = legline_marker.get_markersize() * legend.markerscale
+                legline_marker.set_markersize(newsz)
+
+        handle_barlinecols = []
+        handle_caplines = []
+
+        if orig_handle.has_xerr:
+            verts = [((x - xerr_size, y), (x + xerr_size, y))
+                     for x, y in zip(xdata_marker, ydata_marker)]
+            coll = mcoll.LineCollection(verts)
+            self.update_prop(coll, barlinecols[0], legend)
+            handle_barlinecols.append(coll)
+
+            if caplines:
+                capline_left = Line2D(xdata_marker - xerr_size, ydata_marker)
+                capline_right = Line2D(xdata_marker + xerr_size, ydata_marker)
+                self.update_prop(capline_left, caplines[0], legend)
+                self.update_prop(capline_right, caplines[0], legend)
+                capline_left.set_marker("|")
+                capline_right.set_marker("|")
+
+                handle_caplines.append(capline_left)
+                handle_caplines.append(capline_right)
+
+        if orig_handle.has_yerr:
+            verts = [((x, y - yerr_size), (x, y + yerr_size))
+                     for x, y in zip(xdata_marker, ydata_marker)]
+            coll = mcoll.LineCollection(verts)
+            self.update_prop(coll, barlinecols[0], legend)
+            handle_barlinecols.append(coll)
+
+            if caplines:
+                capline_left = Line2D(xdata_marker, ydata_marker - yerr_size)
+                capline_right = Line2D(xdata_marker, ydata_marker + yerr_size)
+                self.update_prop(capline_left, caplines[0], legend)
+                self.update_prop(capline_right, caplines[0], legend)
+                capline_left.set_marker("_")
+                capline_right.set_marker("_")
+
+                handle_caplines.append(capline_left)
+                handle_caplines.append(capline_right)
+
+        artists = [
+            *handle_barlinecols, *handle_caplines, legline, legline_marker,
+        ]
+        for artist in artists:
+            artist.set_transform(trans)
+        return artists
+
+
+class HandlerStem(HandlerNpointsYoffsets):
+    """
+    Handler for plots produced by `~.Axes.stem`.
+    """
+
+    def __init__(self, marker_pad=0.3, numpoints=None,
+                 bottom=None, yoffsets=None, **kwargs):
+        """
+        Parameters
+        ----------
+        marker_pad : float, default: 0.3
+            Padding between points in legend entry.
+        numpoints : int, optional
+            Number of points to show in legend entry.
+        bottom : float, optional
+
+        yoffsets : array of floats, optional
+            Length *numpoints* list of y offsets for each point in
+            legend entry.
+        **kwargs
+            Keyword arguments forwarded to `.HandlerNpointsYoffsets`.
+        """
+        super().__init__(marker_pad=marker_pad, numpoints=numpoints,
+                         yoffsets=yoffsets, **kwargs)
+        self._bottom = bottom
+
+    def get_ydata(self, legend, xdescent, ydescent, width, height, fontsize):
+        if self._yoffsets is None:
+            ydata = height * (0.5 * legend._scatteryoffsets + 0.5)
+        else:
+            ydata = height * np.asarray(self._yoffsets)
+
+        return ydata
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize,
+                       trans):
+        # docstring inherited
+        markerline, stemlines, baseline = orig_handle
+        # Check to see if the stemcontainer is storing lines as a list or a
+        # LineCollection. Eventually using a list will be removed, and this
+        # logic can also be removed.
+        using_linecoll = isinstance(stemlines, mcoll.LineCollection)
+
+        xdata, xdata_marker = self.get_xdata(legend, xdescent, ydescent,
+                                             width, height, fontsize)
+
+        ydata = self.get_ydata(legend, xdescent, ydescent,
+                               width, height, fontsize)
+
+        if self._bottom is None:
+            bottom = 0.
+        else:
+            bottom = self._bottom
+
+        leg_markerline = Line2D(xdata_marker, ydata[:len(xdata_marker)])
+        self.update_prop(leg_markerline, markerline, legend)
+
+        leg_stemlines = [Line2D([x, x], [bottom, y])
+                         for x, y in zip(xdata_marker, ydata)]
+
+        if using_linecoll:
+            # change the function used by update_prop() from the default
+            # to one that handles LineCollection
+            with cbook._setattr_cm(
+                    self, _update_prop_func=self._copy_collection_props):
+                for line in leg_stemlines:
+                    self.update_prop(line, stemlines, legend)
+
+        else:
+            for lm, m in zip(leg_stemlines, stemlines):
+                self.update_prop(lm, m, legend)
+
+        leg_baseline = Line2D([np.min(xdata), np.max(xdata)],
+                              [bottom, bottom])
+        self.update_prop(leg_baseline, baseline, legend)
+
+        artists = [*leg_stemlines, leg_baseline, leg_markerline]
+        for artist in artists:
+            artist.set_transform(trans)
+        return artists
+
+    def _copy_collection_props(self, legend_handle, orig_handle):
+        """
+        Copy properties from the `.LineCollection` *orig_handle* to the
+        `.Line2D` *legend_handle*.
+        """
+        legend_handle.set_color(orig_handle.get_color()[0])
+        legend_handle.set_linestyle(orig_handle.get_linestyle()[0])
+
+
+class HandlerTuple(HandlerBase):
+    """
+    Handler for Tuple.
+    """
+
+    def __init__(self, ndivide=1, pad=None, **kwargs):
+        """
+        Parameters
+        ----------
+        ndivide : int or None, default: 1
+            The number of sections to divide the legend area into.  If None,
+            use the length of the input tuple.
+        pad : float, default: :rc:`legend.borderpad`
+            Padding in units of fraction of font size.
+        **kwargs
+            Keyword arguments forwarded to `.HandlerBase`.
+        """
+        self._ndivide = ndivide
+        self._pad = pad
+        super().__init__(**kwargs)
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize,
+                       trans):
+        # docstring inherited
+        handler_map = legend.get_legend_handler_map()
+
+        if self._ndivide is None:
+            ndivide = len(orig_handle)
+        else:
+            ndivide = self._ndivide
+
+        if self._pad is None:
+            pad = legend.borderpad * fontsize
+        else:
+            pad = self._pad * fontsize
+
+        if ndivide > 1:
+            width = (width - pad * (ndivide - 1)) / ndivide
+
+        xds_cycle = cycle(xdescent - (width + pad) * np.arange(ndivide))
+
+        a_list = []
+        for handle1 in orig_handle:
+            handler = legend.get_legend_handler(handler_map, handle1)
+            _a_list = handler.create_artists(
+                legend, handle1,
+                next(xds_cycle), ydescent, width, height, fontsize, trans)
+            a_list.extend(_a_list)
+
+        return a_list
+
+
+class HandlerPolyCollection(HandlerBase):
+    """
+    Handler for `.PolyCollection` used in `~.Axes.fill_between` and
+    `~.Axes.stackplot`.
+    """
+    def _update_prop(self, legend_handle, orig_handle):
+        def first_color(colors):
+            if colors.size == 0:
+                return (0, 0, 0, 0)
+            return tuple(colors[0])
+
+        def get_first(prop_array):
+            if len(prop_array):
+                return prop_array[0]
+            else:
+                return None
+
+        # orig_handle is a PolyCollection and legend_handle is a Patch.
+        # Directly set Patch color attributes (must be RGBA tuples).
+        legend_handle._facecolor = first_color(orig_handle.get_facecolor())
+        legend_handle._edgecolor = first_color(orig_handle.get_edgecolor())
+        legend_handle._original_facecolor = orig_handle._original_facecolor
+        legend_handle._original_edgecolor = orig_handle._original_edgecolor
+        legend_handle._fill = orig_handle.get_fill()
+        legend_handle._hatch = orig_handle.get_hatch()
+        # Hatch color is anomalous in having no getters and setters.
+        legend_handle._hatch_color = orig_handle._hatch_color
+        # Setters are fine for the remaining attributes.
+        legend_handle.set_linewidth(get_first(orig_handle.get_linewidths()))
+        legend_handle.set_linestyle(get_first(orig_handle.get_linestyles()))
+        legend_handle.set_transform(get_first(orig_handle.get_transforms()))
+        # Alpha is already taken into account by the color attributes.
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize, trans):
+        # docstring inherited
+        p = Rectangle(xy=(-xdescent, -ydescent),
+                      width=width, height=height)
+        self.update_prop(p, orig_handle, legend)
+        p.set_transform(trans)
+        return [p]

outputs/audit_venv/lib/python3.11/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]: ...

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/lines.py

@@ -0,0 +1,1720 @@
+"""
+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_dash_patterns(styles):
+    """Convert linestyle or sequence of linestyles to list of dash patterns."""
+    try:
+        patterns = [_get_dash_pattern(styles)]
+    except ValueError:
+        try:
+            patterns = [_get_dash_pattern(x) for x in styles]
+        except ValueError as err:
+            emsg = f'Do not know how to convert {styles!r} to dashes'
+            raise ValueError(emsg) from err
+
+    return patterns
+
+
+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

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/lines.pyi

@@ -0,0 +1,153 @@
+from .artist import Artist
+from .axes import Axes
+from .backend_bases import MouseEvent, FigureCanvasBase
+from .path import Path
+from .transforms import Bbox
+
+from collections.abc import Callable, Sequence
+from typing import Any, Literal, overload
+from .typing import (
+    ColorType,
+    DrawStyleType,
+    FillStyleType,
+    LineStyleType,
+    CapStyleType,
+    JoinStyleType,
+    MarkEveryType,
+    MarkerType,
+)
+from numpy.typing import ArrayLike
+
+def segment_hits(
+    cx: ArrayLike, cy: ArrayLike, x: ArrayLike, y: ArrayLike, radius: ArrayLike
+) -> ArrayLike: ...
+
+class Line2D(Artist):
+    lineStyles: dict[str, str]
+    drawStyles: dict[str, str]
+    drawStyleKeys: list[str]
+    markers: dict[str | int, str]
+    filled_markers: tuple[str, ...]
+    fillStyles: tuple[str, ...]
+    zorder: float
+    ind_offset: float
+    def __init__(
+        self,
+        xdata: ArrayLike,
+        ydata: ArrayLike,
+        *,
+        linewidth: float | None = ...,
+        linestyle: LineStyleType | None = ...,
+        color: ColorType | None = ...,
+        gapcolor: ColorType | None = ...,
+        marker: MarkerType | None = ...,
+        markersize: float | None = ...,
+        markeredgewidth: float | None = ...,
+        markeredgecolor: ColorType | None = ...,
+        markerfacecolor: ColorType | None = ...,
+        markerfacecoloralt: ColorType = ...,
+        fillstyle: FillStyleType | None = ...,
+        antialiased: bool | None = ...,
+        dash_capstyle: CapStyleType | None = ...,
+        solid_capstyle: CapStyleType | None = ...,
+        dash_joinstyle: JoinStyleType | None = ...,
+        solid_joinstyle: JoinStyleType | None = ...,
+        pickradius: float = ...,
+        drawstyle: DrawStyleType | None = ...,
+        markevery: MarkEveryType | None = ...,
+        **kwargs
+    ) -> None: ...
+    def contains(self, mouseevent: MouseEvent) -> tuple[bool, dict]: ...
+    def get_pickradius(self) -> float: ...
+    def set_pickradius(self, pickradius: float) -> None: ...
+    pickradius: float
+    def get_fillstyle(self) -> FillStyleType: ...
+    stale: bool
+    def set_fillstyle(self, fs: FillStyleType) -> None: ...
+    def set_markevery(self, every: MarkEveryType) -> None: ...
+    def get_markevery(self) -> MarkEveryType: ...
+    def set_picker(
+        self, p: None | bool | float | Callable[[Artist, MouseEvent], tuple[bool, dict]]
+    ) -> None: ...
+    def get_bbox(self) -> Bbox: ...
+    @overload
+    def set_data(self, args: ArrayLike) -> None: ...
+    @overload
+    def set_data(self, x: ArrayLike, y: ArrayLike) -> None: ...
+    def recache_always(self) -> None: ...
+    def recache(self, always: bool = ...) -> None: ...
+    def get_antialiased(self) -> bool: ...
+    def get_color(self) -> ColorType: ...
+    def get_drawstyle(self) -> DrawStyleType: ...
+    def get_gapcolor(self) -> ColorType: ...
+    def get_linestyle(self) -> LineStyleType: ...
+    def get_linewidth(self) -> float: ...
+    def get_marker(self) -> MarkerType: ...
+    def get_markeredgecolor(self) -> ColorType: ...
+    def get_markeredgewidth(self) -> float: ...
+    def get_markerfacecolor(self) -> ColorType: ...
+    def get_markerfacecoloralt(self) -> ColorType: ...
+    def get_markersize(self) -> float: ...
+    def get_data(self, orig: bool = ...) -> tuple[ArrayLike, ArrayLike]: ...
+    def get_xdata(self, orig: bool = ...) -> ArrayLike: ...
+    def get_ydata(self, orig: bool = ...) -> ArrayLike: ...
+    def get_path(self) -> Path: ...
+    def get_xydata(self) -> ArrayLike: ...
+    def set_antialiased(self, b: bool) -> None: ...
+    def set_color(self, color: ColorType) -> None: ...
+    def set_drawstyle(self, drawstyle: DrawStyleType | None) -> None: ...
+    def set_gapcolor(self, gapcolor: ColorType | None) -> None: ...
+    def set_linewidth(self, w: float) -> None: ...
+    def set_linestyle(self, ls: LineStyleType) -> None: ...
+    def set_marker(self, marker: MarkerType) -> None: ...
+    def set_markeredgecolor(self, ec: ColorType | None) -> None: ...
+    def set_markerfacecolor(self, fc: ColorType | None) -> None: ...
+    def set_markerfacecoloralt(self, fc: ColorType | None) -> None: ...
+    def set_markeredgewidth(self, ew: float | None) -> None: ...
+    def set_markersize(self, sz: float) -> None: ...
+    def set_xdata(self, x: ArrayLike) -> None: ...
+    def set_ydata(self, y: ArrayLike) -> None: ...
+    def set_dashes(self, seq: Sequence[float] | tuple[None, None]) -> None: ...
+    def update_from(self, other: Artist) -> None: ...
+    def set_dash_joinstyle(self, s: JoinStyleType) -> None: ...
+    def set_solid_joinstyle(self, s: JoinStyleType) -> None: ...
+    def get_dash_joinstyle(self) -> Literal["miter", "round", "bevel"]: ...
+    def get_solid_joinstyle(self) -> Literal["miter", "round", "bevel"]: ...
+    def set_dash_capstyle(self, s: CapStyleType) -> None: ...
+    def set_solid_capstyle(self, s: CapStyleType) -> None: ...
+    def get_dash_capstyle(self) -> Literal["butt", "projecting", "round"]: ...
+    def get_solid_capstyle(self) -> Literal["butt", "projecting", "round"]: ...
+    def is_dashed(self) -> bool: ...
+
+class AxLine(Line2D):
+    def __init__(
+        self,
+        xy1: tuple[float, float],
+        xy2: tuple[float, float] | None,
+        slope: float | None,
+        **kwargs
+    ) -> None: ...
+    def get_xy1(self) -> tuple[float, float] | None: ...
+    def get_xy2(self) -> tuple[float, float] | None: ...
+    def get_slope(self) -> float: ...
+    def set_xy1(self, xy1: tuple[float, float]) -> None: ...
+    def set_xy2(self, xy2: tuple[float, float]) -> None: ...
+    def set_slope(self, slope: float) -> None: ...
+
+class VertexSelector:
+    axes: Axes
+    line: Line2D
+    cid: int
+    ind: set[int]
+    def __init__(self, line: Line2D) -> None: ...
+    @property
+    def canvas(self) -> FigureCanvasBase: ...
+    def process_selected(
+        self, ind: Sequence[int], xs: ArrayLike, ys: ArrayLike
+    ) -> None: ...
+    def onpick(self, event: Any) -> None: ...
+
+lineStyles: dict[str, str]
+lineMarkers: dict[str | int, str]
+drawStyles: dict[str, str]
+fillStyles: tuple[FillStyleType, ...]

outputs/audit_venv/lib/python3.11/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)

outputs/audit_venv/lib/python3.11/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: ...

outputs/audit_venv/lib/python3.11/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

outputs/audit_venv/lib/python3.11/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: ...

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mlab.py

@@ -0,0 +1,913 @@
+"""
+Numerical Python functions written for compatibility with MATLAB
+commands with the same names. Most numerical Python functions can be found in
+the `NumPy`_ and `SciPy`_ libraries. What remains here is code for performing
+spectral computations and kernel density estimations.
+
+.. _NumPy: https://numpy.org
+.. _SciPy: https://www.scipy.org
+
+Spectral functions
+------------------
+
+`cohere`
+    Coherence (normalized cross spectral density)
+
+`csd`
+    Cross spectral density using Welch's average periodogram
+
+`detrend`
+    Remove the mean or best fit line from an array
+
+`psd`
+    Power spectral density using Welch's average periodogram
+
+`specgram`
+    Spectrogram (spectrum over segments of time)
+
+`complex_spectrum`
+    Return the complex-valued frequency spectrum of a signal
+
+`magnitude_spectrum`
+    Return the magnitude of the frequency spectrum of a signal
+
+`angle_spectrum`
+    Return the angle (wrapped phase) of the frequency spectrum of a signal
+
+`phase_spectrum`
+    Return the phase (unwrapped angle) of the frequency spectrum of a signal
+
+`detrend_mean`
+    Remove the mean from a line.
+
+`detrend_linear`
+    Remove the best fit line from a line.
+
+`detrend_none`
+    Return the original line.
+"""
+
+import functools
+from numbers import Number
+
+import numpy as np
+
+from matplotlib import _api, _docstring, cbook
+
+
+def window_hanning(x):
+    """
+    Return *x* times the Hanning (or Hann) window of len(*x*).
+
+    See Also
+    --------
+    window_none : Another window algorithm.
+    """
+    return np.hanning(len(x))*x
+
+
+def window_none(x):
+    """
+    No window function; simply return *x*.
+
+    See Also
+    --------
+    window_hanning : Another window algorithm.
+    """
+    return x
+
+
+def detrend(x, key=None, axis=None):
+    """
+    Return *x* with its trend removed.
+
+    Parameters
+    ----------
+    x : array or sequence
+        Array or sequence containing the data.
+
+    key : {'default', 'constant', 'mean', 'linear', 'none'} or function
+        The detrending algorithm to use. 'default', 'mean', and 'constant' are
+        the same as `detrend_mean`. 'linear' is the same as `detrend_linear`.
+        'none' is the same as `detrend_none`. The default is 'mean'. See the
+        corresponding functions for more details regarding the algorithms. Can
+        also be a function that carries out the detrend operation.
+
+    axis : int
+        The axis along which to do the detrending.
+
+    See Also
+    --------
+    detrend_mean : Implementation of the 'mean' algorithm.
+    detrend_linear : Implementation of the 'linear' algorithm.
+    detrend_none : Implementation of the 'none' algorithm.
+    """
+    if key is None or key in ['constant', 'mean', 'default']:
+        return detrend(x, key=detrend_mean, axis=axis)
+    elif key == 'linear':
+        return detrend(x, key=detrend_linear, axis=axis)
+    elif key == 'none':
+        return detrend(x, key=detrend_none, axis=axis)
+    elif callable(key):
+        x = np.asarray(x)
+        if axis is not None and axis + 1 > x.ndim:
+            raise ValueError(f'axis(={axis}) out of bounds')
+        if (axis is None and x.ndim == 0) or (not axis and x.ndim == 1):
+            return key(x)
+        # try to use the 'axis' argument if the function supports it,
+        # otherwise use apply_along_axis to do it
+        try:
+            return key(x, axis=axis)
+        except TypeError:
+            return np.apply_along_axis(key, axis=axis, arr=x)
+    else:
+        raise ValueError(
+            f"Unknown value for key: {key!r}, must be one of: 'default', "
+            f"'constant', 'mean', 'linear', or a function")
+
+
+def detrend_mean(x, axis=None):
+    """
+    Return *x* minus the mean(*x*).
+
+    Parameters
+    ----------
+    x : array or sequence
+        Array or sequence containing the data
+        Can have any dimensionality
+
+    axis : int
+        The axis along which to take the mean.  See `numpy.mean` for a
+        description of this argument.
+
+    See Also
+    --------
+    detrend_linear : Another detrend algorithm.
+    detrend_none : Another detrend algorithm.
+    detrend : A wrapper around all the detrend algorithms.
+    """
+    x = np.asarray(x)
+
+    if axis is not None and axis+1 > x.ndim:
+        raise ValueError('axis(=%s) out of bounds' % axis)
+
+    return x - x.mean(axis, keepdims=True)
+
+
+def detrend_none(x, axis=None):
+    """
+    Return *x*: no detrending.
+
+    Parameters
+    ----------
+    x : any object
+        An object containing the data
+
+    axis : int
+        This parameter is ignored.
+        It is included for compatibility with detrend_mean
+
+    See Also
+    --------
+    detrend_mean : Another detrend algorithm.
+    detrend_linear : Another detrend algorithm.
+    detrend : A wrapper around all the detrend algorithms.
+    """
+    return x
+
+
+def detrend_linear(y):
+    """
+    Return *x* minus best fit line; 'linear' detrending.
+
+    Parameters
+    ----------
+    y : 0-D or 1-D array or sequence
+        Array or sequence containing the data
+
+    See Also
+    --------
+    detrend_mean : Another detrend algorithm.
+    detrend_none : Another detrend algorithm.
+    detrend : A wrapper around all the detrend algorithms.
+    """
+    # This is faster than an algorithm based on linalg.lstsq.
+    y = np.asarray(y)
+
+    if y.ndim > 1:
+        raise ValueError('y cannot have ndim > 1')
+
+    # short-circuit 0-D array.
+    if not y.ndim:
+        return np.array(0., dtype=y.dtype)
+
+    x = np.arange(y.size, dtype=float)
+
+    C = np.cov(x, y, bias=1)
+    b = C[0, 1]/C[0, 0]
+
+    a = y.mean() - b*x.mean()
+    return y - (b*x + a)
+
+
+def _spectral_helper(x, y=None, NFFT=None, Fs=None, detrend_func=None,
+                     window=None, noverlap=None, pad_to=None,
+                     sides=None, scale_by_freq=None, mode=None):
+    """
+    Private helper implementing the common parts between the psd, csd,
+    spectrogram and complex, magnitude, angle, and phase spectrums.
+    """
+    if y is None:
+        # if y is None use x for y
+        same_data = True
+    else:
+        # The checks for if y is x are so that we can use the same function to
+        # implement the core of psd(), csd(), and spectrogram() without doing
+        # extra calculations.  We return the unaveraged Pxy, freqs, and t.
+        same_data = y is x
+
+    if Fs is None:
+        Fs = 2
+    if noverlap is None:
+        noverlap = 0
+    if detrend_func is None:
+        detrend_func = detrend_none
+    if window is None:
+        window = window_hanning
+
+    # if NFFT is set to None use the whole signal
+    if NFFT is None:
+        NFFT = 256
+
+    if noverlap >= NFFT:
+        raise ValueError('noverlap must be less than NFFT')
+
+    if mode is None or mode == 'default':
+        mode = 'psd'
+    _api.check_in_list(
+        ['default', 'psd', 'complex', 'magnitude', 'angle', 'phase'],
+        mode=mode)
+
+    if not same_data and mode != 'psd':
+        raise ValueError("x and y must be equal if mode is not 'psd'")
+
+    # Make sure we're dealing with a numpy array. If y and x were the same
+    # object to start with, keep them that way
+    x = np.asarray(x)
+    if not same_data:
+        y = np.asarray(y)
+
+    if sides is None or sides == 'default':
+        if np.iscomplexobj(x):
+            sides = 'twosided'
+        else:
+            sides = 'onesided'
+    _api.check_in_list(['default', 'onesided', 'twosided'], sides=sides)
+
+    # zero pad x and y up to NFFT if they are shorter than NFFT
+    if len(x) < NFFT:
+        n = len(x)
+        x = np.resize(x, NFFT)
+        x[n:] = 0
+
+    if not same_data and len(y) < NFFT:
+        n = len(y)
+        y = np.resize(y, NFFT)
+        y[n:] = 0
+
+    if pad_to is None:
+        pad_to = NFFT
+
+    if mode != 'psd':
+        scale_by_freq = False
+    elif scale_by_freq is None:
+        scale_by_freq = True
+
+    # For real x, ignore the negative frequencies unless told otherwise
+    if sides == 'twosided':
+        numFreqs = pad_to
+        if pad_to % 2:
+            freqcenter = (pad_to - 1)//2 + 1
+        else:
+            freqcenter = pad_to//2
+        scaling_factor = 1.
+    elif sides == 'onesided':
+        if pad_to % 2:
+            numFreqs = (pad_to + 1)//2
+        else:
+            numFreqs = pad_to//2 + 1
+        scaling_factor = 2.
+
+    if not np.iterable(window):
+        window = window(np.ones(NFFT, x.dtype))
+    if len(window) != NFFT:
+        raise ValueError(
+            "The window length must match the data's first dimension")
+
+    result = np.lib.stride_tricks.sliding_window_view(
+        x, NFFT, axis=0)[::NFFT - noverlap].T
+    result = detrend(result, detrend_func, axis=0)
+    result = result * window.reshape((-1, 1))
+    result = np.fft.fft(result, n=pad_to, axis=0)[:numFreqs, :]
+    freqs = np.fft.fftfreq(pad_to, 1/Fs)[:numFreqs]
+
+    if not same_data:
+        # if same_data is False, mode must be 'psd'
+        resultY = np.lib.stride_tricks.sliding_window_view(
+            y, NFFT, axis=0)[::NFFT - noverlap].T
+        resultY = detrend(resultY, detrend_func, axis=0)
+        resultY = resultY * window.reshape((-1, 1))
+        resultY = np.fft.fft(resultY, n=pad_to, axis=0)[:numFreqs, :]
+        result = np.conj(result) * resultY
+    elif mode == 'psd':
+        result = np.conj(result) * result
+    elif mode == 'magnitude':
+        result = np.abs(result) / window.sum()
+    elif mode == 'angle' or mode == 'phase':
+        # we unwrap the phase later to handle the onesided vs. twosided case
+        result = np.angle(result)
+    elif mode == 'complex':
+        result /= window.sum()
+
+    if mode == 'psd':
+
+        # Also include scaling factors for one-sided densities and dividing by
+        # the sampling frequency, if desired. Scale everything, except the DC
+        # component and the NFFT/2 component:
+
+        # if we have a even number of frequencies, don't scale NFFT/2
+        if not NFFT % 2:
+            slc = slice(1, -1, None)
+        # if we have an odd number, just don't scale DC
+        else:
+            slc = slice(1, None, None)
+
+        result[slc] *= scaling_factor
+
+        # MATLAB divides by the sampling frequency so that density function
+        # has units of dB/Hz and can be integrated by the plotted frequency
+        # values. Perform the same scaling here.
+        if scale_by_freq:
+            result /= Fs
+            # Scale the spectrum by the norm of the window to compensate for
+            # windowing loss; see Bendat & Piersol Sec 11.5.2.
+            result /= (window**2).sum()
+        else:
+            # In this case, preserve power in the segment, not amplitude
+            result /= window.sum()**2
+
+    t = np.arange(NFFT/2, len(x) - NFFT/2 + 1, NFFT - noverlap)/Fs
+
+    if sides == 'twosided':
+        # center the frequency range at zero
+        freqs = np.roll(freqs, -freqcenter, axis=0)
+        result = np.roll(result, -freqcenter, axis=0)
+    elif not pad_to % 2:
+        # get the last value correctly, it is negative otherwise
+        freqs[-1] *= -1
+
+    # we unwrap the phase here to handle the onesided vs. twosided case
+    if mode == 'phase':
+        result = np.unwrap(result, axis=0)
+
+    return result, freqs, t
+
+
+def _single_spectrum_helper(
+        mode, x, Fs=None, window=None, pad_to=None, sides=None):
+    """
+    Private helper implementing the commonality between the complex, magnitude,
+    angle, and phase spectrums.
+    """
+    _api.check_in_list(['complex', 'magnitude', 'angle', 'phase'], mode=mode)
+
+    if pad_to is None:
+        pad_to = len(x)
+
+    spec, freqs, _ = _spectral_helper(x=x, y=None, NFFT=len(x), Fs=Fs,
+                                      detrend_func=detrend_none, window=window,
+                                      noverlap=0, pad_to=pad_to,
+                                      sides=sides,
+                                      scale_by_freq=False,
+                                      mode=mode)
+    if mode != 'complex':
+        spec = spec.real
+
+    if spec.ndim == 2 and spec.shape[1] == 1:
+        spec = spec[:, 0]
+
+    return spec, freqs
+
+
+# Split out these keyword docs so that they can be used elsewhere
+_docstring.interpd.register(
+    Spectral="""\
+Fs : float, default: 2
+    The sampling frequency (samples per time unit).  It is used to calculate
+    the Fourier frequencies, *freqs*, in cycles per time unit.
+
+window : callable or ndarray, default: `.window_hanning`
+    A function or a vector of length *NFFT*.  To create window vectors see
+    `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,
+    `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a
+    function is passed as the argument, it must take a data segment as an
+    argument and return the windowed version of the segment.
+
+sides : {'default', 'onesided', 'twosided'}, optional
+    Which sides of the spectrum to return. 'default' is one-sided for real
+    data and two-sided for complex data. 'onesided' forces the return of a
+    one-sided spectrum, while 'twosided' forces two-sided.""",
+
+    Single_Spectrum="""\
+pad_to : int, optional
+    The number of points to which the data segment is padded when performing
+    the FFT.  While not increasing the actual resolution of the spectrum (the
+    minimum distance between resolvable peaks), this can give more points in
+    the plot, allowing for more detail. This corresponds to the *n* parameter
+    in the call to `~numpy.fft.fft`.  The default is None, which sets *pad_to*
+    equal to the length of the input signal (i.e. no padding).""",
+
+    PSD="""\
+pad_to : int, optional
+    The number of points to which the data segment is padded when performing
+    the FFT.  This can be different from *NFFT*, which specifies the number
+    of data points used.  While not increasing the actual resolution of the
+    spectrum (the minimum distance between resolvable peaks), this can give
+    more points in the plot, allowing for more detail. This corresponds to
+    the *n* parameter in the call to `~numpy.fft.fft`. The default is None,
+    which sets *pad_to* equal to *NFFT*
+
+NFFT : int, default: 256
+    The number of data points used in each block for the FFT.  A power 2 is
+    most efficient.  This should *NOT* be used to get zero padding, or the
+    scaling of the result will be incorrect; use *pad_to* for this instead.
+
+detrend : {'none', 'mean', 'linear'} or callable, default: 'none'
+    The function applied to each segment before fft-ing, designed to remove
+    the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter
+    is a vector, in Matplotlib it is a function.  The :mod:`~matplotlib.mlab`
+    module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,
+    but you can use a custom function as well.  You can also use a string to
+    choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls
+    `.detrend_mean`. 'linear' calls `.detrend_linear`.
+
+scale_by_freq : bool, default: True
+    Whether the resulting density values should be scaled by the scaling
+    frequency, which gives density in units of 1/Hz.  This allows for
+    integration over the returned frequency values.  The default is True for
+    MATLAB compatibility.""")
+
+
+@_docstring.interpd
+def psd(x, NFFT=None, Fs=None, detrend=None, window=None,
+        noverlap=None, pad_to=None, sides=None, scale_by_freq=None):
+    r"""
+    Compute the power spectral density.
+
+    The power spectral density :math:`P_{xx}` by Welch's average
+    periodogram method.  The vector *x* is divided into *NFFT* length
+    segments.  Each segment is detrended by function *detrend* and
+    windowed by function *window*.  *noverlap* gives the length of
+    the overlap between segments.  The :math:`|\mathrm{fft}(i)|^2`
+    of each segment :math:`i` are averaged to compute :math:`P_{xx}`.
+
+    If len(*x*) < *NFFT*, it will be zero padded to *NFFT*.
+
+    Parameters
+    ----------
+    x : 1-D array or sequence
+        Array or sequence containing the data
+
+    %(Spectral)s
+
+    %(PSD)s
+
+    noverlap : int, default: 0 (no overlap)
+        The number of points of overlap between segments.
+
+    Returns
+    -------
+    Pxx : 1-D array
+        The values for the power spectrum :math:`P_{xx}` (real valued)
+
+    freqs : 1-D array
+        The frequencies corresponding to the elements in *Pxx*
+
+    References
+    ----------
+    Bendat & Piersol -- Random Data: Analysis and Measurement Procedures, John
+    Wiley & Sons (1986)
+
+    See Also
+    --------
+    specgram
+        `specgram` differs in the default overlap; in not returning the mean of
+        the segment periodograms; and in returning the times of the segments.
+
+    magnitude_spectrum : returns the magnitude spectrum.
+
+    csd : returns the spectral density between two signals.
+    """
+    Pxx, freqs = csd(x=x, y=None, NFFT=NFFT, Fs=Fs, detrend=detrend,
+                     window=window, noverlap=noverlap, pad_to=pad_to,
+                     sides=sides, scale_by_freq=scale_by_freq)
+    return Pxx.real, freqs
+
+
+@_docstring.interpd
+def csd(x, y, NFFT=None, Fs=None, detrend=None, window=None,
+        noverlap=None, pad_to=None, sides=None, scale_by_freq=None):
+    """
+    Compute the cross-spectral density.
+
+    The cross spectral density :math:`P_{xy}` by Welch's average
+    periodogram method.  The vectors *x* and *y* are divided into
+    *NFFT* length segments.  Each segment is detrended by function
+    *detrend* and windowed by function *window*.  *noverlap* gives
+    the length of the overlap between segments.  The product of
+    the direct FFTs of *x* and *y* are averaged over each segment
+    to compute :math:`P_{xy}`, with a scaling to correct for power
+    loss due to windowing.
+
+    If len(*x*) < *NFFT* or len(*y*) < *NFFT*, they will be zero
+    padded to *NFFT*.
+
+    Parameters
+    ----------
+    x, y : 1-D arrays or sequences
+        Arrays or sequences containing the data
+
+    %(Spectral)s
+
+    %(PSD)s
+
+    noverlap : int, default: 0 (no overlap)
+        The number of points of overlap between segments.
+
+    Returns
+    -------
+    Pxy : 1-D array
+        The values for the cross spectrum :math:`P_{xy}` before scaling (real
+        valued)
+
+    freqs : 1-D array
+        The frequencies corresponding to the elements in *Pxy*
+
+    References
+    ----------
+    Bendat & Piersol -- Random Data: Analysis and Measurement Procedures, John
+    Wiley & Sons (1986)
+
+    See Also
+    --------
+    psd : equivalent to setting ``y = x``.
+    """
+    if NFFT is None:
+        NFFT = 256
+    Pxy, freqs, _ = _spectral_helper(x=x, y=y, NFFT=NFFT, Fs=Fs,
+                                     detrend_func=detrend, window=window,
+                                     noverlap=noverlap, pad_to=pad_to,
+                                     sides=sides, scale_by_freq=scale_by_freq,
+                                     mode='psd')
+
+    if Pxy.ndim == 2:
+        if Pxy.shape[1] > 1:
+            Pxy = Pxy.mean(axis=1)
+        else:
+            Pxy = Pxy[:, 0]
+    return Pxy, freqs
+
+
+_single_spectrum_docs = """\
+Compute the {quantity} of *x*.
+Data is padded to a length of *pad_to* and the windowing function *window* is
+applied to the signal.
+
+Parameters
+----------
+x : 1-D array or sequence
+    Array or sequence containing the data
+
+{Spectral}
+
+{Single_Spectrum}
+
+Returns
+-------
+spectrum : 1-D array
+    The {quantity}.
+freqs : 1-D array
+    The frequencies corresponding to the elements in *spectrum*.
+
+See Also
+--------
+psd
+    Returns the power spectral density.
+complex_spectrum
+    Returns the complex-valued frequency spectrum.
+magnitude_spectrum
+    Returns the absolute value of the `complex_spectrum`.
+angle_spectrum
+    Returns the angle of the `complex_spectrum`.
+phase_spectrum
+    Returns the phase (unwrapped angle) of the `complex_spectrum`.
+specgram
+    Can return the complex spectrum of segments within the signal.
+"""
+
+
+complex_spectrum = functools.partial(_single_spectrum_helper, "complex")
+complex_spectrum.__doc__ = _single_spectrum_docs.format(
+    quantity="complex-valued frequency spectrum",
+    **_docstring.interpd.params)
+magnitude_spectrum = functools.partial(_single_spectrum_helper, "magnitude")
+magnitude_spectrum.__doc__ = _single_spectrum_docs.format(
+    quantity="magnitude (absolute value) of the frequency spectrum",
+    **_docstring.interpd.params)
+angle_spectrum = functools.partial(_single_spectrum_helper, "angle")
+angle_spectrum.__doc__ = _single_spectrum_docs.format(
+    quantity="angle of the frequency spectrum (wrapped phase spectrum)",
+    **_docstring.interpd.params)
+phase_spectrum = functools.partial(_single_spectrum_helper, "phase")
+phase_spectrum.__doc__ = _single_spectrum_docs.format(
+    quantity="phase of the frequency spectrum (unwrapped phase spectrum)",
+    **_docstring.interpd.params)
+
+
+@_docstring.interpd
+def specgram(x, NFFT=None, Fs=None, detrend=None, window=None,
+             noverlap=None, pad_to=None, sides=None, scale_by_freq=None,
+             mode=None):
+    """
+    Compute a spectrogram.
+
+    Compute and plot a spectrogram of data in *x*.  Data are split into
+    *NFFT* length segments and the spectrum of each section is
+    computed.  The windowing function *window* is applied to each
+    segment, and the amount of overlap of each segment is
+    specified with *noverlap*.
+
+    Parameters
+    ----------
+    x : array-like
+        1-D array or sequence.
+
+    %(Spectral)s
+
+    %(PSD)s
+
+    noverlap : int, default: 128
+        The number of points of overlap between blocks.
+    mode : str, default: 'psd'
+        What sort of spectrum to use:
+            'psd'
+                Returns the power spectral density.
+            'complex'
+                Returns the complex-valued frequency spectrum.
+            'magnitude'
+                Returns the magnitude spectrum.
+            'angle'
+                Returns the phase spectrum without unwrapping.
+            'phase'
+                Returns the phase spectrum with unwrapping.
+
+    Returns
+    -------
+    spectrum : array-like
+        2D array, columns are the periodograms of successive segments.
+
+    freqs : array-like
+        1-D array, frequencies corresponding to the rows in *spectrum*.
+
+    t : array-like
+        1-D array, the times corresponding to midpoints of segments
+        (i.e the columns in *spectrum*).
+
+    See Also
+    --------
+    psd : differs in the overlap and in the return values.
+    complex_spectrum : similar, but with complex valued frequencies.
+    magnitude_spectrum : similar single segment when *mode* is 'magnitude'.
+    angle_spectrum : similar to single segment when *mode* is 'angle'.
+    phase_spectrum : similar to single segment when *mode* is 'phase'.
+
+    Notes
+    -----
+    *detrend* and *scale_by_freq* only apply when *mode* is set to 'psd'.
+
+    """
+    if noverlap is None:
+        noverlap = 128  # default in _spectral_helper() is noverlap = 0
+    if NFFT is None:
+        NFFT = 256  # same default as in _spectral_helper()
+    if len(x) <= NFFT:
+        _api.warn_external("Only one segment is calculated since parameter "
+                           f"NFFT (={NFFT}) >= signal length (={len(x)}).")
+
+    spec, freqs, t = _spectral_helper(x=x, y=None, NFFT=NFFT, Fs=Fs,
+                                      detrend_func=detrend, window=window,
+                                      noverlap=noverlap, pad_to=pad_to,
+                                      sides=sides,
+                                      scale_by_freq=scale_by_freq,
+                                      mode=mode)
+
+    if mode != 'complex':
+        spec = spec.real  # Needed since helper implements generically
+
+    return spec, freqs, t
+
+
+@_docstring.interpd
+def cohere(x, y, NFFT=256, Fs=2, detrend=detrend_none, window=window_hanning,
+           noverlap=0, pad_to=None, sides='default', scale_by_freq=None):
+    r"""
+    The coherence between *x* and *y*.  Coherence is the normalized
+    cross spectral density:
+
+    .. math::
+
+        C_{xy} = \frac{|P_{xy}|^2}{P_{xx}P_{yy}}
+
+    Parameters
+    ----------
+    x, y
+        Array or sequence containing the data
+
+    %(Spectral)s
+
+    %(PSD)s
+
+    noverlap : int, default: 0 (no overlap)
+        The number of points of overlap between segments.
+
+    Returns
+    -------
+    Cxy : 1-D array
+        The coherence vector.
+    freqs : 1-D array
+            The frequencies for the elements in *Cxy*.
+
+    See Also
+    --------
+    :func:`psd`, :func:`csd` :
+        For information about the methods used to compute :math:`P_{xy}`,
+        :math:`P_{xx}` and :math:`P_{yy}`.
+    """
+    if len(x) < 2 * NFFT:
+        raise ValueError(
+            "Coherence is calculated by averaging over *NFFT* length "
+            "segments.  Your signal is too short for your choice of *NFFT*.")
+    Pxx, f = psd(x, NFFT, Fs, detrend, window, noverlap, pad_to, sides,
+                 scale_by_freq)
+    Pyy, f = psd(y, NFFT, Fs, detrend, window, noverlap, pad_to, sides,
+                 scale_by_freq)
+    Pxy, f = csd(x, y, NFFT, Fs, detrend, window, noverlap, pad_to, sides,
+                 scale_by_freq)
+    Cxy = np.abs(Pxy) ** 2 / (Pxx * Pyy)
+    return Cxy, f
+
+
+class GaussianKDE:
+    """
+    Representation of a kernel-density estimate using Gaussian kernels.
+
+    Parameters
+    ----------
+    dataset : array-like
+        Datapoints to estimate from. In case of univariate data this is a 1-D
+        array, otherwise a 2D array with shape (# of dims, # of data).
+    bw_method : {'scott', 'silverman'} or float or callable, optional
+        The method used to calculate the estimator bandwidth.  If a
+        float, this will be used directly as `kde.factor`.  If a
+        callable, it should take a `GaussianKDE` instance as only
+        parameter and return a float. If None (default), 'scott' is used.
+
+    Attributes
+    ----------
+    dataset : ndarray
+        The dataset passed to the constructor.
+    dim : int
+        Number of dimensions.
+    num_dp : int
+        Number of datapoints.
+    factor : float
+        The bandwidth factor, obtained from `kde.covariance_factor`, with which
+        the covariance matrix is multiplied.
+    covariance : ndarray
+        The covariance matrix of *dataset*, scaled by the calculated bandwidth
+        (`kde.factor`).
+    inv_cov : ndarray
+        The inverse of *covariance*.
+
+    Methods
+    -------
+    kde.evaluate(points) : ndarray
+        Evaluate the estimated pdf on a provided set of points.
+    kde(points) : ndarray
+        Same as kde.evaluate(points)
+    """
+
+    # This implementation with minor modification was too good to pass up.
+    # from scipy: https://github.com/scipy/scipy/blob/master/scipy/stats/kde.py
+
+    def __init__(self, dataset, bw_method=None):
+        self.dataset = np.atleast_2d(dataset)
+        if not np.array(self.dataset).size > 1:
+            raise ValueError("`dataset` input should have multiple elements.")
+
+        self.dim, self.num_dp = np.array(self.dataset).shape
+
+        if bw_method is None:
+            pass
+        elif cbook._str_equal(bw_method, 'scott'):
+            self.covariance_factor = self.scotts_factor
+        elif cbook._str_equal(bw_method, 'silverman'):
+            self.covariance_factor = self.silverman_factor
+        elif isinstance(bw_method, Number):
+            self._bw_method = 'use constant'
+            self.covariance_factor = lambda: bw_method
+        elif callable(bw_method):
+            self._bw_method = bw_method
+            self.covariance_factor = lambda: self._bw_method(self)
+        else:
+            raise ValueError("`bw_method` should be 'scott', 'silverman', a "
+                             "scalar or a callable")
+
+        # Computes the covariance matrix for each Gaussian kernel using
+        # covariance_factor().
+
+        self.factor = self.covariance_factor()
+        # Cache covariance and inverse covariance of the data
+        if not hasattr(self, '_data_inv_cov'):
+            self.data_covariance = np.atleast_2d(
+                np.cov(
+                    self.dataset,
+                    rowvar=1,
+                    bias=False))
+            self.data_inv_cov = np.linalg.inv(self.data_covariance)
+
+        self.covariance = self.data_covariance * self.factor ** 2
+        self.inv_cov = self.data_inv_cov / self.factor ** 2
+        self.norm_factor = (np.sqrt(np.linalg.det(2 * np.pi * self.covariance))
+                            * self.num_dp)
+
+    def scotts_factor(self):
+        return np.power(self.num_dp, -1. / (self.dim + 4))
+
+    def silverman_factor(self):
+        return np.power(
+            self.num_dp * (self.dim + 2.0) / 4.0, -1. / (self.dim + 4))
+
+    #  Default method to calculate bandwidth, can be overwritten by subclass
+    covariance_factor = scotts_factor
+
+    def evaluate(self, points):
+        """
+        Evaluate the estimated pdf on a set of points.
+
+        Parameters
+        ----------
+        points : (# of dimensions, # of points)-array
+            Alternatively, a (# of dimensions,) vector can be passed in and
+            treated as a single point.
+
+        Returns
+        -------
+        (# of points,)-array
+            The values at each point.
+
+        Raises
+        ------
+        ValueError : if the dimensionality of the input points is different
+                     than the dimensionality of the KDE.
+
+        """
+        points = np.atleast_2d(points)
+
+        dim, num_m = np.array(points).shape
+        if dim != self.dim:
+            raise ValueError(f"points have dimension {dim}, dataset has "
+                             f"dimension {self.dim}")
+
+        result = np.zeros(num_m)
+
+        if num_m >= self.num_dp:
+            # there are more points than data, so loop over data
+            for i in range(self.num_dp):
+                diff = self.dataset[:, i, np.newaxis] - points
+                tdiff = np.dot(self.inv_cov, diff)
+                energy = np.sum(diff * tdiff, axis=0) / 2.0
+                result = result + np.exp(-energy)
+        else:
+            # loop over points
+            for i in range(num_m):
+                diff = self.dataset - points[:, i, np.newaxis]
+                tdiff = np.dot(self.inv_cov, diff)
+                energy = np.sum(diff * tdiff, axis=0) / 2.0
+                result[i] = np.sum(np.exp(-energy), axis=0)
+
+        result = result / self.norm_factor
+
+        return result
+
+    __call__ = evaluate

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mlab.pyi

@@ -0,0 +1,100 @@
+from collections.abc import Callable
+import functools
+from typing import Literal
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+def window_hanning(x: ArrayLike) -> ArrayLike: ...
+def window_none(x: ArrayLike) -> ArrayLike: ...
+def detrend(
+    x: ArrayLike,
+    key: Literal["default", "constant", "mean", "linear", "none"]
+    | Callable[[ArrayLike, int | None], ArrayLike]
+    | None = ...,
+    axis: int | None = ...,
+) -> ArrayLike: ...
+def detrend_mean(x: ArrayLike, axis: int | None = ...) -> ArrayLike: ...
+def detrend_none(x: ArrayLike, axis: int | None = ...) -> ArrayLike: ...
+def detrend_linear(y: ArrayLike) -> ArrayLike: ...
+def psd(
+    x: ArrayLike,
+    NFFT: int | None = ...,
+    Fs: float | None = ...,
+    detrend: Literal["none", "mean", "linear"]
+    | Callable[[ArrayLike, int | None], ArrayLike]
+    | None = ...,
+    window: Callable[[ArrayLike], ArrayLike] | ArrayLike | None = ...,
+    noverlap: int | None = ...,
+    pad_to: int | None = ...,
+    sides: Literal["default", "onesided", "twosided"] | None = ...,
+    scale_by_freq: bool | None = ...,
+) -> tuple[ArrayLike, ArrayLike]: ...
+def csd(
+    x: ArrayLike,
+    y: ArrayLike | None,
+    NFFT: int | None = ...,
+    Fs: float | None = ...,
+    detrend: Literal["none", "mean", "linear"]
+    | Callable[[ArrayLike, int | None], ArrayLike]
+    | None = ...,
+    window: Callable[[ArrayLike], ArrayLike] | ArrayLike | None = ...,
+    noverlap: int | None = ...,
+    pad_to: int | None = ...,
+    sides: Literal["default", "onesided", "twosided"] | None = ...,
+    scale_by_freq: bool | None = ...,
+) -> tuple[ArrayLike, ArrayLike]: ...
+
+complex_spectrum = functools.partial(tuple[ArrayLike, ArrayLike])
+magnitude_spectrum = functools.partial(tuple[ArrayLike, ArrayLike])
+angle_spectrum = functools.partial(tuple[ArrayLike, ArrayLike])
+phase_spectrum = functools.partial(tuple[ArrayLike, ArrayLike])
+
+def specgram(
+    x: ArrayLike,
+    NFFT: int | None = ...,
+    Fs: float | None = ...,
+    detrend: Literal["none", "mean", "linear"] | Callable[[ArrayLike, int | None], ArrayLike] | None = ...,
+    window: Callable[[ArrayLike], ArrayLike] | ArrayLike | None = ...,
+    noverlap: int | None = ...,
+    pad_to: int | None = ...,
+    sides: Literal["default", "onesided", "twosided"] | None = ...,
+    scale_by_freq: bool | None = ...,
+    mode: Literal["psd", "complex", "magnitude", "angle", "phase"] | None = ...,
+) -> tuple[ArrayLike, ArrayLike, ArrayLike]: ...
+def cohere(
+    x: ArrayLike,
+    y: ArrayLike,
+    NFFT: int = ...,
+    Fs: float = ...,
+    detrend: Literal["none", "mean", "linear"] | Callable[[ArrayLike, int | None], ArrayLike] = ...,
+    window: Callable[[ArrayLike], ArrayLike] | ArrayLike = ...,
+    noverlap: int = ...,
+    pad_to: int | None = ...,
+    sides: Literal["default", "onesided", "twosided"] = ...,
+    scale_by_freq: bool | None = ...,
+) -> tuple[ArrayLike, ArrayLike]: ...
+
+class GaussianKDE:
+    dataset: ArrayLike
+    dim: int
+    num_dp: int
+    factor: float
+    data_covariance: ArrayLike
+    data_inv_cov: ArrayLike
+    covariance: ArrayLike
+    inv_cov: ArrayLike
+    norm_factor: float
+    def __init__(
+        self,
+        dataset: ArrayLike,
+        bw_method: Literal["scott", "silverman"]
+        | float
+        | Callable[[GaussianKDE], float]
+        | None = ...,
+    ) -> None: ...
+    def scotts_factor(self) -> float: ...
+    def silverman_factor(self) -> float: ...
+    def covariance_factor(self) -> float: ...
+    def evaluate(self, points: ArrayLike) -> np.ndarray: ...
+    def __call__(self, points: ArrayLike) -> np.ndarray: ...

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/afm/cmex10.afm

@@ -0,0 +1,220 @@
+StartFontMetrics 2.0
+Comment Creation Date: Thu Jun 21 22:23:20 1990
+Comment UniqueID 5000774
+FontName CMEX10
+EncodingScheme FontSpecific
+FullName CMEX10
+FamilyName Computer Modern
+Weight Medium
+ItalicAngle 0
+IsFixedPitch false
+Version 1.00
+Notice Copyright (c) 1997 American Mathematical Society.  All Rights Reserved.
+Comment Computer Modern fonts were designed by Donald E. Knuth
+FontBBox -24 -2960 1454 772
+XHeight 430.556
+Comment CapHeight 0
+Ascender 750
+Comment Descender -1760
+Descender -2960
+Comment FontID CMEX
+Comment DesignSize 10 (pts)
+Comment CharacterCodingScheme TeX math extension
+Comment Space 0 0 0 
+Comment ExtraSpace 0
+Comment Quad 1000
+Comment DefaultRuleThickness 40
+Comment BigOpSpacing 111.111 166.667 200 600 100
+Comment Ascendible characters (74)		% macro  - PS charname
+Comment Ascending 0, 16, 18, 32, 48		% (	 - parenleft
+Comment Ascending 1, 17, 19, 33, 49		% )	 - parenright
+Comment Ascending 2, 104, 20, 34, 50		% [	 - bracketleft
+Comment Ascending 3, 105, 21, 35, 51		% ] 	 - bracketright
+Comment Ascending 4, 106, 22, 36, 52		% lfloor - floorleft
+Comment Ascending 5, 107, 23, 37, 53		% rfloor - floorright
+Comment Ascending 6, 108, 24, 38, 54		% lceil	 - ceilingleft
+Comment Ascending 7, 109, 25, 39, 55		% rceil	 - ceilingright
+Comment Ascending 8, 110, 26, 40, 56		% {	 - braceleft
+Comment Ascending 9, 111, 27, 41, 57		% }	 - braceright
+Comment Ascending 10, 68, 28, 42		% <	 - anglebracketleft
+Comment Ascending 11, 69, 29, 43		% >	 - anglebracketright
+Comment Ascending 14, 46, 30, 44		% /	 - slash
+Comment Ascending 15, 47, 31, 45		% \	 - backslash
+Comment Ascending 70, 71			% bigsqcup  - unionsq
+Comment Ascending 72, 73			% oint	    - contintegral
+Comment Ascending 74, 75			% bigodot   - circledot
+Comment Ascending 76, 77			% bigoplus  - circleplus
+Comment Ascending 78, 79			% bigotimes - circlemultiply
+Comment Ascending 80, 88			% sum       - summation
+Comment Ascending 81, 89			% prod      - product
+Comment Ascending 82, 90			% int       - integral
+Comment Ascending 83, 91			% bigcup    - union
+Comment Ascending 84, 92			% bigcap    - intersection
+Comment Ascending 85, 93			% biguplus  - unionmulti
+Comment Ascending 86, 94			% bigwedge  - logicaland
+Comment Ascending 87, 95			% bigvee    - logicalor
+Comment Ascending 96, 97			% coprod    - coproduct
+Comment Ascending 98, 99, 100			% widehat   - hatwide
+Comment Ascending 101, 102, 103			% widetilde - tildewide
+Comment Ascending 112, 113, 114, 115, 116	% radical   - sqrt
+Comment Extensible characters (28)
+Comment Extensible 12 top 0 mid 0 bot 0 rep 12	    % vert   - thin bar
+Comment Extensible 13 top 0 mid 0 bot 0 rep 13	    % Vert   - thin double bar
+Comment Extensible 48 top 48 mid 0 bot 64 rep 66    % (      - parenleft
+Comment Extensible 49 top 49 mid 0 bot 65 rep 67    % )      - parenright
+Comment Extensible 50 top 50 mid 0 bot 52 rep 54    % [      - bracketleft
+Comment Extensible 51 top 51 mid 0 bot 53 rep 55    % ]      - bracketright
+Comment Extensible 52 top 0 mid 0 bot 52 rep 54	    % lfloor - floorleft
+Comment Extensible 53 top 0 mid 0 bot 53 rep 55	    % rfloor - floorright
+Comment Extensible 54 top 50 mid 0 bot 0 rep 54	    % lceil  - ceilingleft
+Comment Extensible 55 top 51 mid 0 bot 0 rep 55	    % rceil  - ceilingright
+Comment Extensible 56 top 56 mid 60 bot 58 rep 62   % {      - braceleft
+Comment Extensible 57 top 57 mid 61 bot 59 rep 62   % }      - braceright
+Comment Extensible 58 top 56 mid 0 bot 58 rep 62    % lgroup
+Comment Extensible 59 top 57 mid 0 bot 59 rep 62    % rgroup
+Comment Extensible 60 top 0 mid 0 bot 0 rep 63	    % arrowvert
+Comment Extensible 61 top 0 mid 0 bot 0 rep 119	    % Arrowvert
+Comment Extensible 62 top 0 mid 0 bot 0 rep 62	    % bracevert
+Comment Extensible 63 top 120 mid 0 bot 121 rep 63  % updownarrow
+Comment Extensible 64 top 56 mid 0 bot 59 rep 62    % lmoustache
+Comment Extensible 65 top 57 mid 0 bot 58 rep 62    % rmoustache
+Comment Extensible 66 top 0 mid 0 bot 0 rep 66	    % parenleftexten
+Comment Extensible 67 top 0 mid 0 bot 0 rep 67	    % parenrightexten
+Comment Extensible 116 top 118 mid 0 bot 116 rep 117	% radical
+Comment Extensible 119 top 126 mid 0 bot 127 rep 119	% Updownarrow
+Comment Extensible 120 top 120 mid 0 bot 0 rep 63	% uparrow
+Comment Extensible 121 top 0 mid 0 bot 121 rep 63	% downarrow
+Comment Extensible 126 top 126 mid 0 bot 0 rep 119	% Uparrow
+Comment Extensible 127 top 0 mid 0 bot 127 rep 119	% Downarrow
+StartCharMetrics 129
+C 0 ; WX 458.333 ; N parenleftbig ; B 152 -1159 413 40 ; 
+C 1 ; WX 458.333 ; N parenrightbig ; B 44 -1159 305 40 ; 
+C 2 ; WX 416.667 ; N bracketleftbig ; B 202 -1159 394 40 ; 
+C 3 ; WX 416.667 ; N bracketrightbig ; B 22 -1159 214 40 ; 
+C 4 ; WX 472.222 ; N floorleftbig ; B 202 -1159 449 40 ; 
+C 5 ; WX 472.222 ; N floorrightbig ; B 22 -1159 269 40 ; 
+C 6 ; WX 472.222 ; N ceilingleftbig ; B 202 -1159 449 40 ; 
+C 7 ; WX 472.222 ; N ceilingrightbig ; B 22 -1159 269 40 ; 
+C 8 ; WX 583.333 ; N braceleftbig ; B 113 -1159 469 40 ; 
+C 9 ; WX 583.333 ; N bracerightbig ; B 113 -1159 469 40 ; 
+C 10 ; WX 472.222 ; N angbracketleftbig ; B 98 -1160 393 40 ; 
+C 11 ; WX 472.222 ; N angbracketrightbig ; B 78 -1160 373 40 ; 
+C 12 ; WX 333.333 ; N vextendsingle ; B 145 -621 188 21 ; 
+C 13 ; WX 555.556 ; N vextenddouble ; B 145 -621 410 21 ; 
+C 14 ; WX 577.778 ; N slashbig ; B 56 -1159 521 40 ; 
+C 15 ; WX 577.778 ; N backslashbig ; B 56 -1159 521 40 ; 
+C 16 ; WX 597.222 ; N parenleftBig ; B 180 -1759 560 40 ; 
+C 17 ; WX 597.222 ; N parenrightBig ; B 36 -1759 416 40 ; 
+C 18 ; WX 736.111 ; N parenleftbigg ; B 208 -2359 700 40 ; 
+C 19 ; WX 736.111 ; N parenrightbigg ; B 35 -2359 527 40 ; 
+C 20 ; WX 527.778 ; N bracketleftbigg ; B 250 -2359 513 40 ; 
+C 21 ; WX 527.778 ; N bracketrightbigg ; B 14 -2359 277 40 ; 
+C 22 ; WX 583.333 ; N floorleftbigg ; B 250 -2359 568 40 ; 
+C 23 ; WX 583.333 ; N floorrightbigg ; B 14 -2359 332 40 ; 
+C 24 ; WX 583.333 ; N ceilingleftbigg ; B 250 -2359 568 40 ; 
+C 25 ; WX 583.333 ; N ceilingrightbigg ; B 14 -2359 332 40 ; 
+C 26 ; WX 750 ; N braceleftbigg ; B 131 -2359 618 40 ; 
+C 27 ; WX 750 ; N bracerightbigg ; B 131 -2359 618 40 ; 
+C 28 ; WX 750 ; N angbracketleftbigg ; B 125 -2359 652 40 ; 
+C 29 ; WX 750 ; N angbracketrightbigg ; B 97 -2359 624 40 ; 
+C 30 ; WX 1044.44 ; N slashbigg ; B 56 -2359 987 40 ; 
+C 31 ; WX 1044.44 ; N backslashbigg ; B 56 -2359 987 40 ; 
+C 32 ; WX 791.667 ; N parenleftBigg ; B 236 -2959 757 40 ; 
+C 33 ; WX 791.667 ; N parenrightBigg ; B 34 -2959 555 40 ; 
+C 34 ; WX 583.333 ; N bracketleftBigg ; B 275 -2959 571 40 ; 
+C 35 ; WX 583.333 ; N bracketrightBigg ; B 11 -2959 307 40 ; 
+C 36 ; WX 638.889 ; N floorleftBigg ; B 275 -2959 627 40 ; 
+C 37 ; WX 638.889 ; N floorrightBigg ; B 11 -2959 363 40 ; 
+C 38 ; WX 638.889 ; N ceilingleftBigg ; B 275 -2959 627 40 ; 
+C 39 ; WX 638.889 ; N ceilingrightBigg ; B 11 -2959 363 40 ; 
+C 40 ; WX 805.556 ; N braceleftBigg ; B 144 -2959 661 40 ; 
+C 41 ; WX 805.556 ; N bracerightBigg ; B 144 -2959 661 40 ; 
+C 42 ; WX 805.556 ; N angbracketleftBigg ; B 139 -2960 697 40 ; 
+C 43 ; WX 805.556 ; N angbracketrightBigg ; B 108 -2960 666 40 ; 
+C 44 ; WX 1277.78 ; N slashBigg ; B 56 -2959 1221 40 ; 
+C 45 ; WX 1277.78 ; N backslashBigg ; B 56 -2959 1221 40 ; 
+C 46 ; WX 811.111 ; N slashBig ; B 56 -1759 754 40 ; 
+C 47 ; WX 811.111 ; N backslashBig ; B 56 -1759 754 40 ; 
+C 48 ; WX 875 ; N parenlefttp ; B 291 -1770 842 39 ; 
+C 49 ; WX 875 ; N parenrighttp ; B 32 -1770 583 39 ; 
+C 50 ; WX 666.667 ; N bracketlefttp ; B 326 -1760 659 39 ; 
+C 51 ; WX 666.667 ; N bracketrighttp ; B 7 -1760 340 39 ; 
+C 52 ; WX 666.667 ; N bracketleftbt ; B 326 -1759 659 40 ; 
+C 53 ; WX 666.667 ; N bracketrightbt ; B 7 -1759 340 40 ; 
+C 54 ; WX 666.667 ; N bracketleftex ; B 326 -601 395 1 ; 
+C 55 ; WX 666.667 ; N bracketrightex ; B 271 -601 340 1 ; 
+C 56 ; WX 888.889 ; N bracelefttp ; B 384 -910 718 -1 ; 
+C 57 ; WX 888.889 ; N bracerighttp ; B 170 -910 504 -1 ; 
+C 58 ; WX 888.889 ; N braceleftbt ; B 384 -899 718 10 ; 
+C 59 ; WX 888.889 ; N bracerightbt ; B 170 -899 504 10 ; 
+C 60 ; WX 888.889 ; N braceleftmid ; B 170 -1810 504 10 ; 
+C 61 ; WX 888.889 ; N bracerightmid ; B 384 -1810 718 10 ; 
+C 62 ; WX 888.889 ; N braceex ; B 384 -310 504 10 ; 
+C 63 ; WX 666.667 ; N arrowvertex ; B 312 -601 355 1 ; 
+C 64 ; WX 875 ; N parenleftbt ; B 291 -1759 842 50 ; 
+C 65 ; WX 875 ; N parenrightbt ; B 32 -1759 583 50 ; 
+C 66 ; WX 875 ; N parenleftex ; B 291 -610 402 10 ; 
+C 67 ; WX 875 ; N parenrightex ; B 472 -610 583 10 ; 
+C 68 ; WX 611.111 ; N angbracketleftBig ; B 112 -1759 522 40 ; 
+C 69 ; WX 611.111 ; N angbracketrightBig ; B 88 -1759 498 40 ; 
+C 70 ; WX 833.333 ; N unionsqtext ; B 56 -1000 776 0 ; 
+C 71 ; WX 1111.11 ; N unionsqdisplay ; B 56 -1400 1054 0 ; 
+C 72 ; WX 472.222 ; N contintegraltext ; B 56 -1111 609 0 ; 
+C 73 ; WX 555.556 ; N contintegraldisplay ; B 56 -2222 943 0 ; 
+C 74 ; WX 1111.11 ; N circledottext ; B 56 -1000 1054 0 ; 
+C 75 ; WX 1511.11 ; N circledotdisplay ; B 56 -1400 1454 0 ; 
+C 76 ; WX 1111.11 ; N circleplustext ; B 56 -1000 1054 0 ; 
+C 77 ; WX 1511.11 ; N circleplusdisplay ; B 56 -1400 1454 0 ; 
+C 78 ; WX 1111.11 ; N circlemultiplytext ; B 56 -1000 1054 0 ; 
+C 79 ; WX 1511.11 ; N circlemultiplydisplay ; B 56 -1400 1454 0 ; 
+C 80 ; WX 1055.56 ; N summationtext ; B 56 -1000 999 0 ; 
+C 81 ; WX 944.444 ; N producttext ; B 56 -1000 887 0 ; 
+C 82 ; WX 472.222 ; N integraltext ; B 56 -1111 609 0 ; 
+C 83 ; WX 833.333 ; N uniontext ; B 56 -1000 776 0 ; 
+C 84 ; WX 833.333 ; N intersectiontext ; B 56 -1000 776 0 ; 
+C 85 ; WX 833.333 ; N unionmultitext ; B 56 -1000 776 0 ; 
+C 86 ; WX 833.333 ; N logicalandtext ; B 56 -1000 776 0 ; 
+C 87 ; WX 833.333 ; N logicalortext ; B 56 -1000 776 0 ; 
+C 88 ; WX 1444.44 ; N summationdisplay ; B 56 -1400 1387 0 ; 
+C 89 ; WX 1277.78 ; N productdisplay ; B 56 -1400 1221 0 ; 
+C 90 ; WX 555.556 ; N integraldisplay ; B 56 -2222 943 0 ; 
+C 91 ; WX 1111.11 ; N uniondisplay ; B 56 -1400 1054 0 ; 
+C 92 ; WX 1111.11 ; N intersectiondisplay ; B 56 -1400 1054 0 ; 
+C 93 ; WX 1111.11 ; N unionmultidisplay ; B 56 -1400 1054 0 ; 
+C 94 ; WX 1111.11 ; N logicalanddisplay ; B 56 -1400 1054 0 ; 
+C 95 ; WX 1111.11 ; N logicalordisplay ; B 56 -1400 1054 0 ; 
+C 96 ; WX 944.444 ; N coproducttext ; B 56 -1000 887 0 ; 
+C 97 ; WX 1277.78 ; N coproductdisplay ; B 56 -1400 1221 0 ; 
+C 98 ; WX 555.556 ; N hatwide ; B -5 562 561 744 ; 
+C 99 ; WX 1000 ; N hatwider ; B -4 575 1003 772 ; 
+C 100 ; WX 1444.44 ; N hatwidest ; B -3 575 1446 772 ; 
+C 101 ; WX 555.556 ; N tildewide ; B 0 608 555 722 ; 
+C 102 ; WX 1000 ; N tildewider ; B 0 624 999 750 ; 
+C 103 ; WX 1444.44 ; N tildewidest ; B 0 623 1443 750 ; 
+C 104 ; WX 472.222 ; N bracketleftBig ; B 226 -1759 453 40 ; 
+C 105 ; WX 472.222 ; N bracketrightBig ; B 18 -1759 245 40 ; 
+C 106 ; WX 527.778 ; N floorleftBig ; B 226 -1759 509 40 ; 
+C 107 ; WX 527.778 ; N floorrightBig ; B 18 -1759 301 40 ; 
+C 108 ; WX 527.778 ; N ceilingleftBig ; B 226 -1759 509 40 ; 
+C 109 ; WX 527.778 ; N ceilingrightBig ; B 18 -1759 301 40 ; 
+C 110 ; WX 666.667 ; N braceleftBig ; B 119 -1759 547 40 ; 
+C 111 ; WX 666.667 ; N bracerightBig ; B 119 -1759 547 40 ; 
+C 112 ; WX 1000 ; N radicalbig ; B 110 -1160 1020 40 ; 
+C 113 ; WX 1000 ; N radicalBig ; B 110 -1760 1020 40 ; 
+C 114 ; WX 1000 ; N radicalbigg ; B 111 -2360 1020 40 ; 
+C 115 ; WX 1000 ; N radicalBigg ; B 111 -2960 1020 40 ; 
+C 116 ; WX 1055.56 ; N radicalbt ; B 111 -1800 742 20 ; 
+C 117 ; WX 1055.56 ; N radicalvertex ; B 702 -620 742 20 ; 
+C 118 ; WX 1055.56 ; N radicaltp ; B 702 -580 1076 40 ; 
+C 119 ; WX 777.778 ; N arrowvertexdbl ; B 257 -601 521 1 ; 
+C 120 ; WX 666.667 ; N arrowtp ; B 111 -600 556 0 ; 
+C 121 ; WX 666.667 ; N arrowbt ; B 111 -600 556 0 ; 
+C 122 ; WX 450 ; N bracehtipdownleft ; B -24 -214 460 120 ; 
+C 123 ; WX 450 ; N bracehtipdownright ; B -10 -214 474 120 ; 
+C 124 ; WX 450 ; N bracehtipupleft ; B -24 0 460 334 ; 
+C 125 ; WX 450 ; N bracehtipupright ; B -10 0 474 334 ; 
+C 126 ; WX 777.778 ; N arrowdbltp ; B 56 -600 722 -1 ; 
+C 127 ; WX 777.778 ; N arrowdblbt ; B 56 -599 722 0 ; 
+C -1 ; WX 333.333 ; N space ; B 0 0 0 0 ;
+EndCharMetrics
+EndFontMetrics

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/afm/cmmi10.afm

@@ -0,0 +1,326 @@
+StartFontMetrics 2.0
+Comment Creation Date: Thu Jun 21 22:23:22 1990
+Comment UniqueID 5000785
+FontName CMMI10
+EncodingScheme FontSpecific
+FullName CMMI10
+FamilyName Computer Modern
+Weight Medium
+ItalicAngle -14.04
+IsFixedPitch false
+Version 1.00A
+Notice Copyright (c) 1997 American Mathematical Society.  All Rights Reserved.
+Comment Computer Modern fonts were designed by Donald E. Knuth
+FontBBox -32 -250 1048 750
+CapHeight 683.333
+XHeight 430.556
+Ascender 694.444
+Descender -194.444
+Comment FontID CMMI
+Comment DesignSize 10 (pts)
+Comment CharacterCodingScheme TeX math italic
+Comment Space 0 0 0 
+Comment Quad 1000
+StartCharMetrics 129
+C 0 ; WX 615.276 ; N Gamma ; B 39 0 723 680 ; 
+C 1 ; WX 833.333 ; N Delta ; B 49 0 787 716 ; 
+C 2 ; WX 762.774 ; N Theta ; B 50 -22 739 705 ; 
+C 3 ; WX 694.444 ; N Lambda ; B 35 0 666 716 ; 
+C 4 ; WX 742.361 ; N Xi ; B 53 0 777 677 ; 
+C 5 ; WX 831.25 ; N Pi ; B 39 0 880 680 ; 
+C 6 ; WX 779.861 ; N Sigma ; B 59 0 807 683 ; 
+C 7 ; WX 583.333 ; N Upsilon ; B 29 0 700 705 ; 
+C 8 ; WX 666.667 ; N Phi ; B 24 0 642 683 ; 
+C 9 ; WX 612.221 ; N Psi ; B 28 0 692 683 ; 
+C 10 ; WX 772.396 ; N Omega ; B 80 0 785 705 ; 
+C 11 ; WX 639.7 ; N alpha ; B 41 -11 601 442 ; 
+C 12 ; WX 565.625 ; N beta ; B 25 -194 590 705 ; 
+C 13 ; WX 517.73 ; N gamma ; B 18 -215 542 442 ; 
+C 14 ; WX 444.444 ; N delta ; B 41 -12 452 705 ; 
+C 15 ; WX 405.902 ; N epsilon1 ; B 47 -11 376 431 ; 
+C 16 ; WX 437.5 ; N zeta ; B 47 -205 474 697 ; 
+C 17 ; WX 496.53 ; N eta ; B 29 -216 496 442 ; 
+C 18 ; WX 469.442 ; N theta ; B 42 -11 455 705 ; 
+C 19 ; WX 353.935 ; N iota ; B 56 -11 324 442 ; 
+C 20 ; WX 576.159 ; N kappa ; B 55 -11 546 442 ; 
+C 21 ; WX 583.333 ; N lambda ; B 53 -13 547 694 ; 
+C 22 ; WX 602.548 ; N mu ; B 30 -216 572 442 ; 
+C 23 ; WX 493.981 ; N nu ; B 53 0 524 442 ; 
+C 24 ; WX 437.5 ; N xi ; B 24 -205 446 697 ; 
+C 25 ; WX 570.025 ; N pi ; B 27 -11 567 431 ; 
+C 26 ; WX 517.014 ; N rho ; B 30 -216 502 442 ; 
+C 27 ; WX 571.429 ; N sigma ; B 38 -11 567 431 ; 
+C 28 ; WX 437.153 ; N tau ; B 27 -12 511 431 ; 
+C 29 ; WX 540.278 ; N upsilon ; B 29 -11 524 443 ; 
+C 30 ; WX 595.833 ; N phi ; B 49 -205 573 694 ; 
+C 31 ; WX 625.691 ; N chi ; B 32 -205 594 442 ; 
+C 32 ; WX 651.39 ; N psi ; B 29 -205 635 694 ; 
+C 33 ; WX 622.453 ; N omega ; B 13 -11 605 443 ; 
+C 34 ; WX 466.316 ; N epsilon ; B 27 -22 428 453 ; 
+C 35 ; WX 591.438 ; N theta1 ; B 29 -11 561 705 ; 
+C 36 ; WX 828.125 ; N pi1 ; B 27 -11 817 431 ; 
+C 37 ; WX 517.014 ; N rho1 ; B 74 -194 502 442 ; 
+C 38 ; WX 362.846 ; N sigma1 ; B 32 -108 408 442 ; 
+C 39 ; WX 654.165 ; N phi1 ; B 50 -218 619 442 ; 
+C 40 ; WX 1000 ; N arrowlefttophalf ; B 56 230 943 428 ; 
+C 41 ; WX 1000 ; N arrowleftbothalf ; B 56 72 943 270 ; 
+C 42 ; WX 1000 ; N arrowrighttophalf ; B 56 230 943 428 ; 
+C 43 ; WX 1000 ; N arrowrightbothalf ; B 56 72 943 270 ; 
+C 44 ; WX 277.778 ; N arrowhookleft ; B 56 230 221 464 ; 
+C 45 ; WX 277.778 ; N arrowhookright ; B 56 230 221 464 ; 
+C 46 ; WX 500 ; N triangleright ; B 27 -4 472 504 ; 
+C 47 ; WX 500 ; N triangleleft ; B 27 -4 472 504 ; 
+C 48 ; WX 500 ; N zerooldstyle ; B 40 -22 459 453 ; 
+C 49 ; WX 500 ; N oneoldstyle ; B 92 0 418 453 ; 
+C 50 ; WX 500 ; N twooldstyle ; B 44 0 449 453 ; 
+C 51 ; WX 500 ; N threeoldstyle ; B 42 -216 457 453 ; 
+C 52 ; WX 500 ; N fouroldstyle ; B 28 -194 471 464 ; 
+C 53 ; WX 500 ; N fiveoldstyle ; B 50 -216 449 453 ; 
+C 54 ; WX 500 ; N sixoldstyle ; B 42 -22 457 666 ; 
+C 55 ; WX 500 ; N sevenoldstyle ; B 56 -216 485 463 ; 
+C 56 ; WX 500 ; N eightoldstyle ; B 42 -22 457 666 ; 
+C 57 ; WX 500 ; N nineoldstyle ; B 42 -216 457 453 ; 
+C 58 ; WX 277.778 ; N period ; B 86 0 192 106 ; 
+C 59 ; WX 277.778 ; N comma ; B 86 -193 203 106 ; 
+C 60 ; WX 777.778 ; N less ; B 83 -39 694 539 ; 
+C 61 ; WX 500 ; N slash ; B 56 -250 443 750 ; 
+C 62 ; WX 777.778 ; N greater ; B 83 -39 694 539 ; 
+C 63 ; WX 500 ; N star ; B 4 16 496 486 ; 
+C 64 ; WX 530.902 ; N partialdiff ; B 40 -22 566 716 ; 
+C 65 ; WX 750 ; N A ; B 35 0 722 716 ; 
+C 66 ; WX 758.508 ; N B ; B 42 0 756 683 ; 
+C 67 ; WX 714.72 ; N C ; B 51 -22 759 705 ; 
+C 68 ; WX 827.915 ; N D ; B 41 0 803 683 ; 
+C 69 ; WX 738.193 ; N E ; B 39 0 765 680 ; 
+C 70 ; WX 643.055 ; N F ; B 39 0 751 680 ; 
+C 71 ; WX 786.247 ; N G ; B 51 -22 760 705 ; 
+C 72 ; WX 831.25 ; N H ; B 39 0 881 683 ; 
+C 73 ; WX 439.583 ; N I ; B 34 0 498 683 ; 
+C 74 ; WX 554.512 ; N J ; B 73 -22 633 683 ; 
+C 75 ; WX 849.305 ; N K ; B 39 0 889 683 ; 
+C 76 ; WX 680.556 ; N L ; B 39 0 643 683 ; 
+C 77 ; WX 970.138 ; N M ; B 43 0 1044 683 ; 
+C 78 ; WX 803.471 ; N N ; B 39 0 881 683 ; 
+C 79 ; WX 762.774 ; N O ; B 50 -22 739 705 ; 
+C 80 ; WX 642.012 ; N P ; B 41 0 753 683 ; 
+C 81 ; WX 790.553 ; N Q ; B 50 -194 739 705 ; 
+C 82 ; WX 759.288 ; N R ; B 41 -22 755 683 ; 
+C 83 ; WX 613.193 ; N S ; B 53 -22 645 705 ; 
+C 84 ; WX 584.375 ; N T ; B 24 0 704 677 ; 
+C 85 ; WX 682.776 ; N U ; B 68 -22 760 683 ; 
+C 86 ; WX 583.333 ; N V ; B 56 -22 769 683 ; 
+C 87 ; WX 944.444 ; N W ; B 55 -22 1048 683 ; 
+C 88 ; WX 828.472 ; N X ; B 27 0 851 683 ; 
+C 89 ; WX 580.556 ; N Y ; B 34 0 762 683 ; 
+C 90 ; WX 682.638 ; N Z ; B 59 0 722 683 ; 
+C 91 ; WX 388.889 ; N flat ; B 56 -22 332 750 ; 
+C 92 ; WX 388.889 ; N natural ; B 79 -217 309 728 ; 
+C 93 ; WX 388.889 ; N sharp ; B 56 -216 332 716 ; 
+C 94 ; WX 1000 ; N slurbelow ; B 56 133 943 371 ; 
+C 95 ; WX 1000 ; N slurabove ; B 56 130 943 381 ; 
+C 96 ; WX 416.667 ; N lscript ; B 11 -12 398 705 ; 
+C 97 ; WX 528.588 ; N a ; B 40 -11 498 442 ; 
+C 98 ; WX 429.165 ; N b ; B 47 -11 415 694 ; 
+C 99 ; WX 432.755 ; N c ; B 41 -11 430 442 ; 
+C 100 ; WX 520.486 ; N d ; B 40 -11 517 694 ; 
+C 101 ; WX 465.625 ; N e ; B 46 -11 430 442 ; 
+C 102 ; WX 489.583 ; N f ; B 53 -205 552 705 ; 
+C 103 ; WX 476.967 ; N g ; B 16 -205 474 442 ; 
+C 104 ; WX 576.159 ; N h ; B 55 -11 546 694 ; 
+C 105 ; WX 344.511 ; N i ; B 29 -11 293 661 ; 
+C 106 ; WX 411.805 ; N j ; B -13 -205 397 661 ; 
+C 107 ; WX 520.602 ; N k ; B 55 -11 508 694 ; 
+C 108 ; WX 298.378 ; N l ; B 46 -11 260 694 ; 
+C 109 ; WX 878.012 ; N m ; B 29 -11 848 442 ; 
+C 110 ; WX 600.233 ; N n ; B 29 -11 571 442 ; 
+C 111 ; WX 484.721 ; N o ; B 41 -11 469 442 ; 
+C 112 ; WX 503.125 ; N p ; B -32 -194 490 442 ; 
+C 113 ; WX 446.412 ; N q ; B 40 -194 453 442 ; 
+C 114 ; WX 451.158 ; N r ; B 29 -11 436 442 ; 
+C 115 ; WX 468.75 ; N s ; B 52 -11 419 442 ; 
+C 116 ; WX 361.111 ; N t ; B 23 -11 330 626 ; 
+C 117 ; WX 572.456 ; N u ; B 29 -11 543 442 ; 
+C 118 ; WX 484.722 ; N v ; B 29 -11 468 443 ; 
+C 119 ; WX 715.916 ; N w ; B 29 -11 691 443 ; 
+C 120 ; WX 571.527 ; N x ; B 29 -11 527 442 ; 
+C 121 ; WX 490.28 ; N y ; B 29 -205 490 442 ; 
+C 122 ; WX 465.048 ; N z ; B 43 -11 467 442 ; 
+C 123 ; WX 322.454 ; N dotlessi ; B 29 -11 293 442 ; 
+C 124 ; WX 384.028 ; N dotlessj ; B -13 -205 360 442 ; 
+C 125 ; WX 636.457 ; N weierstrass ; B 76 -216 618 453 ; 
+C 126 ; WX 500 ; N vector ; B 182 516 625 714 ; 
+C 127 ; WX 277.778 ; N tie ; B 264 538 651 665 ; 
+C -1 ; WX 333.333 ; N space ; B 0 0 0 0 ;
+EndCharMetrics
+Comment The following are bogus kern pairs for TeX positioning of accents
+StartKernData
+StartKernPairs 166
+KPX Gamma slash -55.556
+KPX Gamma comma -111.111
+KPX Gamma period -111.111
+KPX Gamma tie 83.333
+KPX Delta tie 166.667
+KPX Theta tie 83.333
+KPX Lambda tie 166.667
+KPX Xi tie 83.333
+KPX Pi slash -55.556
+KPX Pi comma -55.556
+KPX Pi period -55.556
+KPX Pi tie 55.556
+KPX Sigma tie 83.333
+KPX Upsilon slash -55.556
+KPX Upsilon comma -111.111
+KPX Upsilon period -111.111
+KPX Upsilon tie 55.556
+KPX Phi tie 83.333
+KPX Psi slash -55.556
+KPX Psi comma -55.556
+KPX Psi period -55.556
+KPX Psi tie 55.556
+KPX Omega tie 83.333
+KPX alpha tie 27.778
+KPX beta tie 83.333
+KPX delta comma -55.556
+KPX delta period -55.556
+KPX delta tie 55.556
+KPX epsilon1 tie 55.556
+KPX zeta tie 83.333
+KPX eta tie 55.556
+KPX theta tie 83.333
+KPX iota tie 55.556
+KPX mu tie 27.778
+KPX nu comma -55.556
+KPX nu period -55.556
+KPX nu tie 27.778
+KPX xi tie 111.111
+KPX rho tie 83.333
+KPX sigma comma -55.556
+KPX sigma period -55.556
+KPX tau comma -55.556
+KPX tau period -55.556
+KPX tau tie 27.778
+KPX upsilon tie 27.778
+KPX phi tie 83.333
+KPX chi tie 55.556
+KPX psi tie 111.111
+KPX epsilon tie 83.333
+KPX theta1 tie 83.333
+KPX rho1 tie 83.333
+KPX sigma1 tie 83.333
+KPX phi1 tie 83.333
+KPX slash Delta -55.556
+KPX slash A -55.556
+KPX slash M -55.556
+KPX slash N -55.556
+KPX slash Y 55.556
+KPX slash Z -55.556
+KPX partialdiff tie 83.333
+KPX A tie 138.889
+KPX B tie 83.333
+KPX C slash -27.778
+KPX C comma -55.556
+KPX C period -55.556
+KPX C tie 83.333
+KPX D tie 55.556
+KPX E tie 83.333
+KPX F slash -55.556
+KPX F comma -111.111
+KPX F period -111.111
+KPX F tie 83.333
+KPX G tie 83.333
+KPX H slash -55.556
+KPX H comma -55.556
+KPX H period -55.556
+KPX H tie 55.556
+KPX I tie 111.111
+KPX J slash -55.556
+KPX J comma -111.111
+KPX J period -111.111
+KPX J tie 166.667
+KPX K slash -55.556
+KPX K comma -55.556
+KPX K period -55.556
+KPX K tie 55.556
+KPX L tie 27.778
+KPX M slash -55.556
+KPX M comma -55.556
+KPX M period -55.556
+KPX M tie 83.333
+KPX N slash -83.333
+KPX N slash -27.778
+KPX N comma -55.556
+KPX N period -55.556
+KPX N tie 83.333
+KPX O tie 83.333
+KPX P slash -55.556
+KPX P comma -111.111
+KPX P period -111.111
+KPX P tie 83.333
+KPX Q tie 83.333
+KPX R tie 83.333
+KPX S slash -55.556
+KPX S comma -55.556
+KPX S period -55.556
+KPX S tie 83.333
+KPX T slash -27.778
+KPX T comma -55.556
+KPX T period -55.556
+KPX T tie 83.333
+KPX U comma -111.111
+KPX U period -111.111
+KPX U slash -55.556
+KPX U tie 27.778
+KPX V comma -166.667
+KPX V period -166.667
+KPX V slash -111.111
+KPX W comma -166.667
+KPX W period -166.667
+KPX W slash -111.111
+KPX X slash -83.333
+KPX X slash -27.778
+KPX X comma -55.556
+KPX X period -55.556
+KPX X tie 83.333
+KPX Y comma -166.667
+KPX Y period -166.667
+KPX Y slash -111.111
+KPX Z slash -55.556
+KPX Z comma -55.556
+KPX Z period -55.556
+KPX Z tie 83.333
+KPX lscript tie 111.111
+KPX c tie 55.556
+KPX d Y 55.556
+KPX d Z -55.556
+KPX d j -111.111
+KPX d f -166.667
+KPX d tie 166.667
+KPX e tie 55.556
+KPX f comma -55.556
+KPX f period -55.556
+KPX f tie 166.667
+KPX g tie 27.778
+KPX h tie -27.778
+KPX j comma -55.556
+KPX j period -55.556
+KPX l tie 83.333
+KPX o tie 55.556
+KPX p tie 83.333
+KPX q tie 83.333
+KPX r comma -55.556
+KPX r period -55.556
+KPX r tie 55.556
+KPX s tie 55.556
+KPX t tie 83.333
+KPX u tie 27.778
+KPX v tie 27.778
+KPX w tie 83.333
+KPX x tie 27.778
+KPX y tie 55.556
+KPX z tie 55.556
+KPX dotlessi tie 27.778
+KPX dotlessj tie 83.333
+KPX weierstrass tie 111.111
+EndKernPairs
+EndKernData
+EndFontMetrics

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/afm/cmr10.afm

@@ -0,0 +1,343 @@
+StartFontMetrics 2.0
+Comment Creation Date: Thu Jun 21 22:23:28 1990
+Comment UniqueID 5000793
+FontName CMR10
+EncodingScheme FontSpecific
+FullName CMR10
+FamilyName Computer Modern
+Weight Medium
+ItalicAngle 0.0
+IsFixedPitch false
+Version 1.00B
+Notice Copyright (c) 1997 American Mathematical Society.  All Rights Reserved.
+Comment Computer Modern fonts were designed by Donald E. Knuth
+FontBBox -40 -250 1009 969
+CapHeight 683.333
+XHeight 430.556
+Ascender 694.444
+Descender -194.444
+Comment FontID CMR
+Comment DesignSize 10 (pts)
+Comment CharacterCodingScheme TeX text
+Comment Space 333.333 166.667 111.111 
+Comment ExtraSpace 111.111
+Comment Quad 1000
+StartCharMetrics 129
+C 0 ; WX 625 ; N Gamma ; B 33 0 582 680 ; 
+C 1 ; WX 833.333 ; N Delta ; B 47 0 785 716 ; 
+C 2 ; WX 777.778 ; N Theta ; B 56 -22 721 705 ; 
+C 3 ; WX 694.444 ; N Lambda ; B 32 0 661 716 ; 
+C 4 ; WX 666.667 ; N Xi ; B 42 0 624 677 ; 
+C 5 ; WX 750 ; N Pi ; B 33 0 716 680 ; 
+C 6 ; WX 722.222 ; N Sigma ; B 56 0 665 683 ; 
+C 7 ; WX 777.778 ; N Upsilon ; B 56 0 721 705 ; 
+C 8 ; WX 722.222 ; N Phi ; B 56 0 665 683 ; 
+C 9 ; WX 777.778 ; N Psi ; B 57 0 720 683 ; 
+C 10 ; WX 722.222 ; N Omega ; B 44 0 677 705 ; 
+C 11 ; WX 583.333 ; N ff ; B 27 0 628 705 ; L i ffi ; L l ffl ; 
+C 12 ; WX 555.556 ; N fi ; B 27 0 527 705 ; 
+C 13 ; WX 555.556 ; N fl ; B 27 0 527 705 ; 
+C 14 ; WX 833.333 ; N ffi ; B 27 0 804 705 ; 
+C 15 ; WX 833.333 ; N ffl ; B 27 0 804 705 ; 
+C 16 ; WX 277.778 ; N dotlessi ; B 33 0 247 442 ; 
+C 17 ; WX 305.556 ; N dotlessj ; B -40 -205 210 442 ; 
+C 18 ; WX 500 ; N grave ; B 107 510 293 698 ; 
+C 19 ; WX 500 ; N acute ; B 206 510 392 698 ; 
+C 20 ; WX 500 ; N caron ; B 118 516 381 638 ; 
+C 21 ; WX 500 ; N breve ; B 100 522 399 694 ; 
+C 22 ; WX 500 ; N macron ; B 69 559 430 590 ; 
+C 23 ; WX 750 ; N ring ; B 279 541 470 716 ; 
+C 24 ; WX 444.444 ; N cedilla ; B 131 -203 367 -22 ; 
+C 25 ; WX 500 ; N germandbls ; B 28 -11 471 705 ; 
+C 26 ; WX 722.222 ; N ae ; B 45 -11 693 448 ; 
+C 27 ; WX 777.778 ; N oe ; B 28 -11 749 448 ; 
+C 28 ; WX 500 ; N oslash ; B 35 -102 464 534 ; 
+C 29 ; WX 902.778 ; N AE ; B 32 0 874 683 ; 
+C 30 ; WX 1013.89 ; N OE ; B 70 -22 985 705 ; 
+C 31 ; WX 777.778 ; N Oslash ; B 56 -56 721 739 ; 
+C 32 ; WX 277.778 ; N suppress ; B 27 280 262 392 ; 
+C 33 ; WX 277.778 ; N exclam ; B 86 0 192 716 ; L quoteleft exclamdown ; 
+C 34 ; WX 500 ; N quotedblright ; B 33 395 347 694 ; 
+C 35 ; WX 833.333 ; N numbersign ; B 56 -194 776 694 ; 
+C 36 ; WX 500 ; N dollar ; B 56 -56 443 750 ; 
+C 37 ; WX 833.333 ; N percent ; B 56 -56 776 750 ; 
+C 38 ; WX 777.778 ; N ampersand ; B 42 -22 727 716 ; 
+C 39 ; WX 277.778 ; N quoteright ; B 86 395 206 694 ; L quoteright quotedblright ; 
+C 40 ; WX 388.889 ; N parenleft ; B 99 -250 331 750 ; 
+C 41 ; WX 388.889 ; N parenright ; B 57 -250 289 750 ; 
+C 42 ; WX 500 ; N asterisk ; B 65 319 434 750 ; 
+C 43 ; WX 777.778 ; N plus ; B 56 -83 721 583 ; 
+C 44 ; WX 277.778 ; N comma ; B 86 -193 203 106 ; 
+C 45 ; WX 333.333 ; N hyphen ; B 11 187 276 245 ; L hyphen endash ; 
+C 46 ; WX 277.778 ; N period ; B 86 0 192 106 ; 
+C 47 ; WX 500 ; N slash ; B 56 -250 443 750 ; 
+C 48 ; WX 500 ; N zero ; B 39 -22 460 666 ; 
+C 49 ; WX 500 ; N one ; B 89 0 419 666 ; 
+C 50 ; WX 500 ; N two ; B 50 0 449 666 ; 
+C 51 ; WX 500 ; N three ; B 42 -22 457 666 ; 
+C 52 ; WX 500 ; N four ; B 28 0 471 677 ; 
+C 53 ; WX 500 ; N five ; B 50 -22 449 666 ; 
+C 54 ; WX 500 ; N six ; B 42 -22 457 666 ; 
+C 55 ; WX 500 ; N seven ; B 56 -22 485 676 ; 
+C 56 ; WX 500 ; N eight ; B 42 -22 457 666 ; 
+C 57 ; WX 500 ; N nine ; B 42 -22 457 666 ; 
+C 58 ; WX 277.778 ; N colon ; B 86 0 192 431 ; 
+C 59 ; WX 277.778 ; N semicolon ; B 86 -193 195 431 ; 
+C 60 ; WX 277.778 ; N exclamdown ; B 86 -216 192 500 ; 
+C 61 ; WX 777.778 ; N equal ; B 56 133 721 367 ; 
+C 62 ; WX 472.222 ; N questiondown ; B 56 -205 415 500 ; 
+C 63 ; WX 472.222 ; N question ; B 56 0 415 705 ; L quoteleft questiondown ; 
+C 64 ; WX 777.778 ; N at ; B 56 -11 721 705 ; 
+C 65 ; WX 750 ; N A ; B 32 0 717 716 ; 
+C 66 ; WX 708.333 ; N B ; B 36 0 651 683 ; 
+C 67 ; WX 722.222 ; N C ; B 56 -22 665 705 ; 
+C 68 ; WX 763.889 ; N D ; B 35 0 707 683 ; 
+C 69 ; WX 680.556 ; N E ; B 33 0 652 680 ; 
+C 70 ; WX 652.778 ; N F ; B 33 0 610 680 ; 
+C 71 ; WX 784.722 ; N G ; B 56 -22 735 705 ; 
+C 72 ; WX 750 ; N H ; B 33 0 716 683 ; 
+C 73 ; WX 361.111 ; N I ; B 28 0 333 683 ; 
+C 74 ; WX 513.889 ; N J ; B 41 -22 465 683 ; 
+C 75 ; WX 777.778 ; N K ; B 33 0 736 683 ; 
+C 76 ; WX 625 ; N L ; B 33 0 582 683 ; 
+C 77 ; WX 916.667 ; N M ; B 37 0 879 683 ; 
+C 78 ; WX 750 ; N N ; B 33 0 716 683 ; 
+C 79 ; WX 777.778 ; N O ; B 56 -22 721 705 ; 
+C 80 ; WX 680.556 ; N P ; B 35 0 624 683 ; 
+C 81 ; WX 777.778 ; N Q ; B 56 -194 727 705 ; 
+C 82 ; WX 736.111 ; N R ; B 35 -22 732 683 ; 
+C 83 ; WX 555.556 ; N S ; B 56 -22 499 705 ; 
+C 84 ; WX 722.222 ; N T ; B 36 0 685 677 ; 
+C 85 ; WX 750 ; N U ; B 33 -22 716 683 ; 
+C 86 ; WX 750 ; N V ; B 19 -22 730 683 ; 
+C 87 ; WX 1027.78 ; N W ; B 18 -22 1009 683 ; 
+C 88 ; WX 750 ; N X ; B 24 0 726 683 ; 
+C 89 ; WX 750 ; N Y ; B 11 0 738 683 ; 
+C 90 ; WX 611.111 ; N Z ; B 56 0 560 683 ; 
+C 91 ; WX 277.778 ; N bracketleft ; B 118 -250 255 750 ; 
+C 92 ; WX 500 ; N quotedblleft ; B 152 394 466 693 ; 
+C 93 ; WX 277.778 ; N bracketright ; B 22 -250 159 750 ; 
+C 94 ; WX 500 ; N circumflex ; B 116 540 383 694 ; 
+C 95 ; WX 277.778 ; N dotaccent ; B 85 563 192 669 ; 
+C 96 ; WX 277.778 ; N quoteleft ; B 72 394 192 693 ; L quoteleft quotedblleft ; 
+C 97 ; WX 500 ; N a ; B 42 -11 493 448 ; 
+C 98 ; WX 555.556 ; N b ; B 28 -11 521 694 ; 
+C 99 ; WX 444.444 ; N c ; B 34 -11 415 448 ; 
+C 100 ; WX 555.556 ; N d ; B 34 -11 527 694 ; 
+C 101 ; WX 444.444 ; N e ; B 28 -11 415 448 ; 
+C 102 ; WX 305.556 ; N f ; B 33 0 357 705 ; L i fi ; L f ff ; L l fl ; 
+C 103 ; WX 500 ; N g ; B 28 -206 485 453 ; 
+C 104 ; WX 555.556 ; N h ; B 32 0 535 694 ; 
+C 105 ; WX 277.778 ; N i ; B 33 0 247 669 ; 
+C 106 ; WX 305.556 ; N j ; B -40 -205 210 669 ; 
+C 107 ; WX 527.778 ; N k ; B 28 0 511 694 ; 
+C 108 ; WX 277.778 ; N l ; B 33 0 255 694 ; 
+C 109 ; WX 833.333 ; N m ; B 32 0 813 442 ; 
+C 110 ; WX 555.556 ; N n ; B 32 0 535 442 ; 
+C 111 ; WX 500 ; N o ; B 28 -11 471 448 ; 
+C 112 ; WX 555.556 ; N p ; B 28 -194 521 442 ; 
+C 113 ; WX 527.778 ; N q ; B 34 -194 527 442 ; 
+C 114 ; WX 391.667 ; N r ; B 28 0 364 442 ; 
+C 115 ; WX 394.444 ; N s ; B 33 -11 360 448 ; 
+C 116 ; WX 388.889 ; N t ; B 19 -11 332 615 ; 
+C 117 ; WX 555.556 ; N u ; B 32 -11 535 442 ; 
+C 118 ; WX 527.778 ; N v ; B 19 -11 508 431 ; 
+C 119 ; WX 722.222 ; N w ; B 18 -11 703 431 ; 
+C 120 ; WX 527.778 ; N x ; B 12 0 516 431 ; 
+C 121 ; WX 527.778 ; N y ; B 19 -205 508 431 ; 
+C 122 ; WX 444.444 ; N z ; B 28 0 401 431 ; 
+C 123 ; WX 500 ; N endash ; B 0 255 499 277 ; L hyphen emdash ; 
+C 124 ; WX 1000 ; N emdash ; B 0 255 999 277 ; 
+C 125 ; WX 500 ; N hungarumlaut ; B 128 513 420 699 ; 
+C 126 ; WX 500 ; N tilde ; B 83 575 416 668 ; 
+C 127 ; WX 500 ; N dieresis ; B 103 569 396 669 ; 
+C -1 ; WX 333.333 ; N space ; B 0 0 0 0 ; 
+EndCharMetrics
+StartKernData
+StartKernPairs 183
+KPX ff quoteright 77.778
+KPX ff question 77.778
+KPX ff exclam 77.778
+KPX ff parenright 77.778
+KPX ff bracketright 77.778
+KPX suppress l -277.778
+KPX suppress L -319.444
+KPX quoteright question 111.111
+KPX quoteright exclam 111.111
+KPX A t -27.778
+KPX A C -27.778
+KPX A O -27.778
+KPX A G -27.778
+KPX A U -27.778
+KPX A Q -27.778
+KPX A T -83.333
+KPX A Y -83.333
+KPX A V -111.111
+KPX A W -111.111
+KPX D X -27.778
+KPX D W -27.778
+KPX D A -27.778
+KPX D V -27.778
+KPX D Y -27.778
+KPX F o -83.333
+KPX F e -83.333
+KPX F u -83.333
+KPX F r -83.333
+KPX F a -83.333
+KPX F A -111.111
+KPX F O -27.778
+KPX F C -27.778
+KPX F G -27.778
+KPX F Q -27.778
+KPX I I 27.778
+KPX K O -27.778
+KPX K C -27.778
+KPX K G -27.778
+KPX K Q -27.778
+KPX L T -83.333
+KPX L Y -83.333
+KPX L V -111.111
+KPX L W -111.111
+KPX O X -27.778
+KPX O W -27.778
+KPX O A -27.778
+KPX O V -27.778
+KPX O Y -27.778
+KPX P A -83.333
+KPX P o -27.778
+KPX P e -27.778
+KPX P a -27.778
+KPX P period -83.333
+KPX P comma -83.333
+KPX R t -27.778
+KPX R C -27.778
+KPX R O -27.778
+KPX R G -27.778
+KPX R U -27.778
+KPX R Q -27.778
+KPX R T -83.333
+KPX R Y -83.333
+KPX R V -111.111
+KPX R W -111.111
+KPX T y -27.778
+KPX T e -83.333
+KPX T o -83.333
+KPX T r -83.333
+KPX T a -83.333
+KPX T A -83.333
+KPX T u -83.333
+KPX V o -83.333
+KPX V e -83.333
+KPX V u -83.333
+KPX V r -83.333
+KPX V a -83.333
+KPX V A -111.111
+KPX V O -27.778
+KPX V C -27.778
+KPX V G -27.778
+KPX V Q -27.778
+KPX W o -83.333
+KPX W e -83.333
+KPX W u -83.333
+KPX W r -83.333
+KPX W a -83.333
+KPX W A -111.111
+KPX W O -27.778
+KPX W C -27.778
+KPX W G -27.778
+KPX W Q -27.778
+KPX X O -27.778
+KPX X C -27.778
+KPX X G -27.778
+KPX X Q -27.778
+KPX Y e -83.333
+KPX Y o -83.333
+KPX Y r -83.333
+KPX Y a -83.333
+KPX Y A -83.333
+KPX Y u -83.333
+KPX a v -27.778
+KPX a j 55.556
+KPX a y -27.778
+KPX a w -27.778
+KPX b e 27.778
+KPX b o 27.778
+KPX b x -27.778
+KPX b d 27.778
+KPX b c 27.778
+KPX b q 27.778
+KPX b v -27.778
+KPX b j 55.556
+KPX b y -27.778
+KPX b w -27.778
+KPX c h -27.778
+KPX c k -27.778
+KPX f quoteright 77.778
+KPX f question 77.778
+KPX f exclam 77.778
+KPX f parenright 77.778
+KPX f bracketright 77.778
+KPX g j 27.778
+KPX h t -27.778
+KPX h u -27.778
+KPX h b -27.778
+KPX h y -27.778
+KPX h v -27.778
+KPX h w -27.778
+KPX k a -55.556
+KPX k e -27.778
+KPX k a -27.778
+KPX k o -27.778
+KPX k c -27.778
+KPX m t -27.778
+KPX m u -27.778
+KPX m b -27.778
+KPX m y -27.778
+KPX m v -27.778
+KPX m w -27.778
+KPX n t -27.778
+KPX n u -27.778
+KPX n b -27.778
+KPX n y -27.778
+KPX n v -27.778
+KPX n w -27.778
+KPX o e 27.778
+KPX o o 27.778
+KPX o x -27.778
+KPX o d 27.778
+KPX o c 27.778
+KPX o q 27.778
+KPX o v -27.778
+KPX o j 55.556
+KPX o y -27.778
+KPX o w -27.778
+KPX p e 27.778
+KPX p o 27.778
+KPX p x -27.778
+KPX p d 27.778
+KPX p c 27.778
+KPX p q 27.778
+KPX p v -27.778
+KPX p j 55.556
+KPX p y -27.778
+KPX p w -27.778
+KPX t y -27.778
+KPX t w -27.778
+KPX u w -27.778
+KPX v a -55.556
+KPX v e -27.778
+KPX v a -27.778
+KPX v o -27.778
+KPX v c -27.778
+KPX w e -27.778
+KPX w a -27.778
+KPX w o -27.778
+KPX w c -27.778
+KPX y o -27.778
+KPX y e -27.778
+KPX y a -27.778
+KPX y period -83.333
+KPX y comma -83.333
+EndKernPairs
+EndKernData
+EndFontMetrics

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/afm/cmsy10.afm

@@ -0,0 +1,195 @@
+StartFontMetrics 2.0
+Comment Creation Date: Thu Jun 21 22:23:44 1990
+Comment UniqueID 5000820
+FontName CMSY10
+EncodingScheme FontSpecific
+FullName CMSY10
+FamilyName Computer Modern
+Weight Medium
+ItalicAngle -14.035
+IsFixedPitch false
+Version 1.00
+Notice Copyright (c) 1997 American Mathematical Society.  All Rights Reserved.
+Comment Computer Modern fonts were designed by Donald E. Knuth
+FontBBox -29 -960 1116 775
+CapHeight 683.333
+XHeight 430.556
+Ascender 694.444
+Descender -960
+Comment FontID CMSY
+Comment DesignSize 10 (pts)
+Comment CharacterCodingScheme TeX math symbols
+Comment Space 0 0 0 
+Comment ExtraSpace 0
+Comment Quad 1000
+Comment Num 676.508 393.732 443.731
+Comment Denom 685.951 344.841
+Comment Sup 412.892 362.892 288.889
+Comment Sub 150 247.217
+Comment Supdrop 386.108
+Comment Subdrop 50
+Comment Delim 2390 1010
+Comment Axisheight 250
+StartCharMetrics 129
+C 0 ; WX 777.778 ; N minus ; B 83 230 694 270 ; 
+C 1 ; WX 277.778 ; N periodcentered ; B 86 197 192 303 ; 
+C 2 ; WX 777.778 ; N multiply ; B 147 9 630 491 ; 
+C 3 ; WX 500 ; N asteriskmath ; B 65 34 434 465 ; 
+C 4 ; WX 777.778 ; N divide ; B 56 -30 722 530 ; 
+C 5 ; WX 500 ; N diamondmath ; B 11 11 489 489 ; 
+C 6 ; WX 777.778 ; N plusminus ; B 56 0 721 666 ; 
+C 7 ; WX 777.778 ; N minusplus ; B 56 -166 721 500 ; 
+C 8 ; WX 777.778 ; N circleplus ; B 56 -83 721 583 ; 
+C 9 ; WX 777.778 ; N circleminus ; B 56 -83 721 583 ; 
+C 10 ; WX 777.778 ; N circlemultiply ; B 56 -83 721 583 ; 
+C 11 ; WX 777.778 ; N circledivide ; B 56 -83 721 583 ; 
+C 12 ; WX 777.778 ; N circledot ; B 56 -83 721 583 ; 
+C 13 ; WX 1000 ; N circlecopyrt ; B 56 -216 943 716 ; 
+C 14 ; WX 500 ; N openbullet ; B 56 56 443 444 ; 
+C 15 ; WX 500 ; N bullet ; B 56 56 443 444 ; 
+C 16 ; WX 777.778 ; N equivasymptotic ; B 56 16 721 484 ; 
+C 17 ; WX 777.778 ; N equivalence ; B 56 36 721 464 ; 
+C 18 ; WX 777.778 ; N reflexsubset ; B 83 -137 694 636 ; 
+C 19 ; WX 777.778 ; N reflexsuperset ; B 83 -137 694 636 ; 
+C 20 ; WX 777.778 ; N lessequal ; B 83 -137 694 636 ; 
+C 21 ; WX 777.778 ; N greaterequal ; B 83 -137 694 636 ; 
+C 22 ; WX 777.778 ; N precedesequal ; B 83 -137 694 636 ; 
+C 23 ; WX 777.778 ; N followsequal ; B 83 -137 694 636 ; 
+C 24 ; WX 777.778 ; N similar ; B 56 133 721 367 ; 
+C 25 ; WX 777.778 ; N approxequal ; B 56 56 721 483 ; 
+C 26 ; WX 777.778 ; N propersubset ; B 83 -40 694 540 ; 
+C 27 ; WX 777.778 ; N propersuperset ; B 83 -40 694 540 ; 
+C 28 ; WX 1000 ; N lessmuch ; B 56 -66 943 566 ; 
+C 29 ; WX 1000 ; N greatermuch ; B 56 -66 943 566 ; 
+C 30 ; WX 777.778 ; N precedes ; B 83 -40 694 539 ; 
+C 31 ; WX 777.778 ; N follows ; B 83 -40 694 539 ; 
+C 32 ; WX 1000 ; N arrowleft ; B 57 72 943 428 ; 
+C 33 ; WX 1000 ; N arrowright ; B 56 72 942 428 ; 
+C 34 ; WX 500 ; N arrowup ; B 72 -194 428 693 ; 
+C 35 ; WX 500 ; N arrowdown ; B 72 -193 428 694 ; 
+C 36 ; WX 1000 ; N arrowboth ; B 57 72 942 428 ; 
+C 37 ; WX 1000 ; N arrownortheast ; B 56 -193 946 697 ; 
+C 38 ; WX 1000 ; N arrowsoutheast ; B 56 -197 946 693 ; 
+C 39 ; WX 777.778 ; N similarequal ; B 56 36 721 464 ; 
+C 40 ; WX 1000 ; N arrowdblleft ; B 57 -25 943 525 ; 
+C 41 ; WX 1000 ; N arrowdblright ; B 56 -25 942 525 ; 
+C 42 ; WX 611.111 ; N arrowdblup ; B 30 -194 580 694 ; 
+C 43 ; WX 611.111 ; N arrowdbldown ; B 30 -194 580 694 ; 
+C 44 ; WX 1000 ; N arrowdblboth ; B 35 -25 964 525 ; 
+C 45 ; WX 1000 ; N arrownorthwest ; B 53 -193 943 697 ; 
+C 46 ; WX 1000 ; N arrowsouthwest ; B 53 -197 943 693 ; 
+C 47 ; WX 777.778 ; N proportional ; B 56 -11 722 442 ; 
+C 48 ; WX 275 ; N prime ; B 29 45 262 559 ; 
+C 49 ; WX 1000 ; N infinity ; B 56 -11 943 442 ; 
+C 50 ; WX 666.667 ; N element ; B 83 -40 583 540 ; 
+C 51 ; WX 666.667 ; N owner ; B 83 -40 583 540 ; 
+C 52 ; WX 888.889 ; N triangle ; B 59 0 829 716 ; 
+C 53 ; WX 888.889 ; N triangleinv ; B 59 -216 829 500 ; 
+C 54 ; WX 0 ; N negationslash ; B 139 -216 638 716 ; 
+C 55 ; WX 0 ; N mapsto ; B 56 64 124 436 ; 
+C 56 ; WX 555.556 ; N universal ; B 0 -22 556 694 ; 
+C 57 ; WX 555.556 ; N existential ; B 56 0 499 694 ; 
+C 58 ; WX 666.667 ; N logicalnot ; B 56 89 610 356 ; 
+C 59 ; WX 500 ; N emptyset ; B 47 -78 452 772 ; 
+C 60 ; WX 722.222 ; N Rfractur ; B 46 -22 714 716 ; 
+C 61 ; WX 722.222 ; N Ifractur ; B 56 -11 693 705 ; 
+C 62 ; WX 777.778 ; N latticetop ; B 56 0 722 666 ; 
+C 63 ; WX 777.778 ; N perpendicular ; B 56 0 722 666 ; 
+C 64 ; WX 611.111 ; N aleph ; B 56 0 554 693 ; 
+C 65 ; WX 798.469 ; N A ; B 27 -50 798 722 ; 
+C 66 ; WX 656.808 ; N B ; B 30 -22 665 706 ; 
+C 67 ; WX 526.527 ; N C ; B 12 -24 534 705 ; 
+C 68 ; WX 771.391 ; N D ; B 20 0 766 683 ; 
+C 69 ; WX 527.778 ; N E ; B 28 -22 565 705 ; 
+C 70 ; WX 718.75 ; N F ; B 17 -33 829 683 ; 
+C 71 ; WX 594.864 ; N G ; B 44 -119 601 705 ; 
+C 72 ; WX 844.516 ; N H ; B 20 -47 818 683 ; 
+C 73 ; WX 544.513 ; N I ; B -24 0 635 683 ; 
+C 74 ; WX 677.778 ; N J ; B 47 -119 840 683 ; 
+C 75 ; WX 761.949 ; N K ; B 30 -22 733 705 ; 
+C 76 ; WX 689.723 ; N L ; B 31 -22 656 705 ; 
+C 77 ; WX 1200.9 ; N M ; B 27 -50 1116 705 ; 
+C 78 ; WX 820.489 ; N N ; B -29 -50 978 775 ; 
+C 79 ; WX 796.112 ; N O ; B 57 -22 777 705 ; 
+C 80 ; WX 695.558 ; N P ; B 20 -50 733 683 ; 
+C 81 ; WX 816.667 ; N Q ; B 113 -124 788 705 ; 
+C 82 ; WX 847.502 ; N R ; B 20 -22 837 683 ; 
+C 83 ; WX 605.556 ; N S ; B 18 -22 642 705 ; 
+C 84 ; WX 544.643 ; N T ; B 29 0 798 717 ; 
+C 85 ; WX 625.83 ; N U ; B -17 -28 688 683 ; 
+C 86 ; WX 612.781 ; N V ; B 35 -45 660 683 ; 
+C 87 ; WX 987.782 ; N W ; B 35 -45 1036 683 ; 
+C 88 ; WX 713.295 ; N X ; B 50 0 808 683 ; 
+C 89 ; WX 668.335 ; N Y ; B 31 -135 717 683 ; 
+C 90 ; WX 724.724 ; N Z ; B 37 0 767 683 ; 
+C 91 ; WX 666.667 ; N union ; B 56 -22 610 598 ; 
+C 92 ; WX 666.667 ; N intersection ; B 56 -22 610 598 ; 
+C 93 ; WX 666.667 ; N unionmulti ; B 56 -22 610 598 ; 
+C 94 ; WX 666.667 ; N logicaland ; B 56 -22 610 598 ; 
+C 95 ; WX 666.667 ; N logicalor ; B 56 -22 610 598 ; 
+C 96 ; WX 611.111 ; N turnstileleft ; B 56 0 554 694 ; 
+C 97 ; WX 611.111 ; N turnstileright ; B 56 0 554 694 ; 
+C 98 ; WX 444.444 ; N floorleft ; B 174 -250 422 750 ; 
+C 99 ; WX 444.444 ; N floorright ; B 21 -250 269 750 ; 
+C 100 ; WX 444.444 ; N ceilingleft ; B 174 -250 422 750 ; 
+C 101 ; WX 444.444 ; N ceilingright ; B 21 -250 269 750 ; 
+C 102 ; WX 500 ; N braceleft ; B 72 -250 427 750 ; 
+C 103 ; WX 500 ; N braceright ; B 72 -250 427 750 ; 
+C 104 ; WX 388.889 ; N angbracketleft ; B 110 -250 332 750 ; 
+C 105 ; WX 388.889 ; N angbracketright ; B 56 -250 278 750 ; 
+C 106 ; WX 277.778 ; N bar ; B 119 -250 159 750 ; 
+C 107 ; WX 500 ; N bardbl ; B 132 -250 367 750 ; 
+C 108 ; WX 500 ; N arrowbothv ; B 72 -272 428 772 ; 
+C 109 ; WX 611.111 ; N arrowdblbothv ; B 30 -272 580 772 ; 
+C 110 ; WX 500 ; N backslash ; B 56 -250 443 750 ; 
+C 111 ; WX 277.778 ; N wreathproduct ; B 56 -83 221 583 ; 
+C 112 ; WX 833.333 ; N radical ; B 73 -960 853 40 ; 
+C 113 ; WX 750 ; N coproduct ; B 36 0 713 683 ; 
+C 114 ; WX 833.333 ; N nabla ; B 47 -33 785 683 ; 
+C 115 ; WX 416.667 ; N integral ; B 56 -216 471 716 ; 
+C 116 ; WX 666.667 ; N unionsq ; B 61 0 605 598 ; 
+C 117 ; WX 666.667 ; N intersectionsq ; B 61 0 605 598 ; 
+C 118 ; WX 777.778 ; N subsetsqequal ; B 83 -137 714 636 ; 
+C 119 ; WX 777.778 ; N supersetsqequal ; B 63 -137 694 636 ; 
+C 120 ; WX 444.444 ; N section ; B 69 -205 374 705 ; 
+C 121 ; WX 444.444 ; N dagger ; B 56 -216 387 705 ; 
+C 122 ; WX 444.444 ; N daggerdbl ; B 56 -205 387 705 ; 
+C 123 ; WX 611.111 ; N paragraph ; B 56 -194 582 694 ; 
+C 124 ; WX 777.778 ; N club ; B 28 -130 750 727 ; 
+C 125 ; WX 777.778 ; N diamond ; B 56 -163 722 727 ; 
+C 126 ; WX 777.778 ; N heart ; B 56 -33 722 716 ; 
+C 127 ; WX 777.778 ; N spade ; B 56 -130 722 727 ; 
+C -1 ; WX 333.333 ; N space ; B 0 0 0 0 ;
+EndCharMetrics
+Comment The following are bogus kern pairs for TeX positioning of accents
+StartKernData
+StartKernPairs 26
+KPX A prime 194.444
+KPX B prime 138.889
+KPX C prime 138.889
+KPX D prime 83.333
+KPX E prime 111.111
+KPX F prime 111.111
+KPX G prime 111.111
+KPX H prime 111.111
+KPX I prime 27.778
+KPX J prime 166.667
+KPX K prime 55.556
+KPX L prime 138.889
+KPX M prime 138.889
+KPX N prime 83.333
+KPX O prime 111.111
+KPX P prime 83.333
+KPX Q prime 111.111
+KPX R prime 83.333
+KPX S prime 138.889
+KPX T prime 27.778
+KPX U prime 83.333
+KPX V prime 27.778
+KPX W prime 83.333
+KPX X prime 138.889
+KPX Y prime 83.333
+KPX Z prime 138.889
+EndKernPairs
+EndKernData
+EndFontMetrics

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/afm/cmtt10.afm

@@ -0,0 +1,156 @@
+StartFontMetrics 2.0
+Comment Creation Date: Thu Jun 21 22:23:51 1990
+Comment UniqueID 5000832
+FontName CMTT10
+EncodingScheme FontSpecific
+FullName CMTT10
+FamilyName Computer Modern
+Weight Medium
+ItalicAngle 0.0
+IsFixedPitch true
+Version 1.00B
+Notice Copyright (c) 1997 American Mathematical Society.  All Rights Reserved.
+Comment Computer Modern fonts were designed by Donald E. Knuth
+FontBBox -4 -235 731 800
+CapHeight 611.111
+XHeight 430.556
+Ascender 611.111
+Descender -222.222
+Comment FontID CMTT
+Comment DesignSize 10 (pts)
+Comment CharacterCodingScheme TeX typewriter text
+Comment Space 525 0 0 
+Comment ExtraSpace 525
+Comment Quad 1050
+StartCharMetrics 129
+C 0 ; WX 525 ; N Gamma ; B 32 0 488 611 ; 
+C 1 ; WX 525 ; N Delta ; B 34 0 490 623 ; 
+C 2 ; WX 525 ; N Theta ; B 56 -11 468 622 ; 
+C 3 ; WX 525 ; N Lambda ; B 29 0 495 623 ; 
+C 4 ; WX 525 ; N Xi ; B 33 0 491 611 ; 
+C 5 ; WX 525 ; N Pi ; B 22 0 502 611 ; 
+C 6 ; WX 525 ; N Sigma ; B 40 0 484 611 ; 
+C 7 ; WX 525 ; N Upsilon ; B 38 0 486 622 ; 
+C 8 ; WX 525 ; N Phi ; B 40 0 484 611 ; 
+C 9 ; WX 525 ; N Psi ; B 38 0 486 611 ; 
+C 10 ; WX 525 ; N Omega ; B 32 0 492 622 ; 
+C 11 ; WX 525 ; N arrowup ; B 59 0 465 611 ; 
+C 12 ; WX 525 ; N arrowdown ; B 59 0 465 611 ; 
+C 13 ; WX 525 ; N quotesingle ; B 217 328 309 622 ; 
+C 14 ; WX 525 ; N exclamdown ; B 212 -233 312 389 ; 
+C 15 ; WX 525 ; N questiondown ; B 62 -228 462 389 ; 
+C 16 ; WX 525 ; N dotlessi ; B 78 0 455 431 ; 
+C 17 ; WX 525 ; N dotlessj ; B 48 -228 368 431 ; 
+C 18 ; WX 525 ; N grave ; B 117 477 329 611 ; 
+C 19 ; WX 525 ; N acute ; B 195 477 407 611 ; 
+C 20 ; WX 525 ; N caron ; B 101 454 423 572 ; 
+C 21 ; WX 525 ; N breve ; B 86 498 438 611 ; 
+C 22 ; WX 525 ; N macron ; B 73 514 451 577 ; 
+C 23 ; WX 525 ; N ring ; B 181 499 343 619 ; 
+C 24 ; WX 525 ; N cedilla ; B 162 -208 428 45 ; 
+C 25 ; WX 525 ; N germandbls ; B 17 -6 495 617 ; 
+C 26 ; WX 525 ; N ae ; B 33 -6 504 440 ; 
+C 27 ; WX 525 ; N oe ; B 19 -6 505 440 ; 
+C 28 ; WX 525 ; N oslash ; B 43 -140 481 571 ; 
+C 29 ; WX 525 ; N AE ; B 23 0 499 611 ; 
+C 30 ; WX 525 ; N OE ; B 29 -11 502 622 ; 
+C 31 ; WX 525 ; N Oslash ; B 56 -85 468 696 ; 
+C 32 ; WX 525 ; N visiblespace ; B 44 -132 480 240 ; 
+C 33 ; WX 525 ; N exclam ; B 212 0 312 622 ; L quoteleft exclamdown ; 
+C 34 ; WX 525 ; N quotedbl ; B 126 328 398 622 ; 
+C 35 ; WX 525 ; N numbersign ; B 35 0 489 611 ; 
+C 36 ; WX 525 ; N dollar ; B 58 -83 466 694 ; 
+C 37 ; WX 525 ; N percent ; B 35 -83 489 694 ; 
+C 38 ; WX 525 ; N ampersand ; B 28 -11 490 622 ; 
+C 39 ; WX 525 ; N quoteright ; B 180 302 341 611 ; 
+C 40 ; WX 525 ; N parenleft ; B 173 -82 437 694 ; 
+C 41 ; WX 525 ; N parenright ; B 88 -82 352 694 ; 
+C 42 ; WX 525 ; N asterisk ; B 68 90 456 521 ; 
+C 43 ; WX 525 ; N plus ; B 38 81 486 531 ; 
+C 44 ; WX 525 ; N comma ; B 180 -139 346 125 ; 
+C 45 ; WX 525 ; N hyphen ; B 56 271 468 341 ; 
+C 46 ; WX 525 ; N period ; B 200 0 325 125 ; 
+C 47 ; WX 525 ; N slash ; B 58 -83 466 694 ; 
+C 48 ; WX 525 ; N zero ; B 50 -11 474 622 ; 
+C 49 ; WX 525 ; N one ; B 105 0 442 622 ; 
+C 50 ; WX 525 ; N two ; B 52 0 472 622 ; 
+C 51 ; WX 525 ; N three ; B 44 -11 480 622 ; 
+C 52 ; WX 525 ; N four ; B 29 0 495 623 ; 
+C 53 ; WX 525 ; N five ; B 52 -11 472 611 ; 
+C 54 ; WX 525 ; N six ; B 53 -11 471 622 ; 
+C 55 ; WX 525 ; N seven ; B 44 -11 480 627 ; 
+C 56 ; WX 525 ; N eight ; B 44 -11 480 622 ; 
+C 57 ; WX 525 ; N nine ; B 53 -11 471 622 ; 
+C 58 ; WX 525 ; N colon ; B 200 0 325 431 ; 
+C 59 ; WX 525 ; N semicolon ; B 180 -139 330 431 ; 
+C 60 ; WX 525 ; N less ; B 56 56 468 556 ; 
+C 61 ; WX 525 ; N equal ; B 38 195 486 417 ; 
+C 62 ; WX 525 ; N greater ; B 56 56 468 556 ; 
+C 63 ; WX 525 ; N question ; B 62 0 462 617 ; L quoteleft questiondown ; 
+C 64 ; WX 525 ; N at ; B 44 -6 480 617 ; 
+C 65 ; WX 525 ; N A ; B 27 0 497 623 ; 
+C 66 ; WX 525 ; N B ; B 23 0 482 611 ; 
+C 67 ; WX 525 ; N C ; B 40 -11 484 622 ; 
+C 68 ; WX 525 ; N D ; B 19 0 485 611 ; 
+C 69 ; WX 525 ; N E ; B 26 0 502 611 ; 
+C 70 ; WX 525 ; N F ; B 28 0 490 611 ; 
+C 71 ; WX 525 ; N G ; B 38 -11 496 622 ; 
+C 72 ; WX 525 ; N H ; B 22 0 502 611 ; 
+C 73 ; WX 525 ; N I ; B 79 0 446 611 ; 
+C 74 ; WX 525 ; N J ; B 71 -11 478 611 ; 
+C 75 ; WX 525 ; N K ; B 26 0 495 611 ; 
+C 76 ; WX 525 ; N L ; B 32 0 488 611 ; 
+C 77 ; WX 525 ; N M ; B 17 0 507 611 ; 
+C 78 ; WX 525 ; N N ; B 28 0 496 611 ; 
+C 79 ; WX 525 ; N O ; B 56 -11 468 622 ; 
+C 80 ; WX 525 ; N P ; B 26 0 480 611 ; 
+C 81 ; WX 525 ; N Q ; B 56 -139 468 622 ; 
+C 82 ; WX 525 ; N R ; B 22 -11 522 611 ; 
+C 83 ; WX 525 ; N S ; B 52 -11 472 622 ; 
+C 84 ; WX 525 ; N T ; B 26 0 498 611 ; 
+C 85 ; WX 525 ; N U ; B 4 -11 520 611 ; 
+C 86 ; WX 525 ; N V ; B 18 -8 506 611 ; 
+C 87 ; WX 525 ; N W ; B 11 -8 513 611 ; 
+C 88 ; WX 525 ; N X ; B 27 0 496 611 ; 
+C 89 ; WX 525 ; N Y ; B 19 0 505 611 ; 
+C 90 ; WX 525 ; N Z ; B 48 0 481 611 ; 
+C 91 ; WX 525 ; N bracketleft ; B 222 -83 483 694 ; 
+C 92 ; WX 525 ; N backslash ; B 58 -83 466 694 ; 
+C 93 ; WX 525 ; N bracketright ; B 41 -83 302 694 ; 
+C 94 ; WX 525 ; N asciicircum ; B 100 471 424 611 ; 
+C 95 ; WX 525 ; N underscore ; B 56 -95 468 -25 ; 
+C 96 ; WX 525 ; N quoteleft ; B 183 372 344 681 ; 
+C 97 ; WX 525 ; N a ; B 55 -6 524 440 ; 
+C 98 ; WX 525 ; N b ; B 12 -6 488 611 ; 
+C 99 ; WX 525 ; N c ; B 73 -6 466 440 ; 
+C 100 ; WX 525 ; N d ; B 36 -6 512 611 ; 
+C 101 ; WX 525 ; N e ; B 55 -6 464 440 ; 
+C 102 ; WX 525 ; N f ; B 42 0 437 617 ; 
+C 103 ; WX 525 ; N g ; B 29 -229 509 442 ; 
+C 104 ; WX 525 ; N h ; B 12 0 512 611 ; 
+C 105 ; WX 525 ; N i ; B 78 0 455 612 ; 
+C 106 ; WX 525 ; N j ; B 48 -228 368 612 ; 
+C 107 ; WX 525 ; N k ; B 21 0 508 611 ; 
+C 108 ; WX 525 ; N l ; B 58 0 467 611 ; 
+C 109 ; WX 525 ; N m ; B -4 0 516 437 ; 
+C 110 ; WX 525 ; N n ; B 12 0 512 437 ; 
+C 111 ; WX 525 ; N o ; B 57 -6 467 440 ; 
+C 112 ; WX 525 ; N p ; B 12 -222 488 437 ; 
+C 113 ; WX 525 ; N q ; B 40 -222 537 437 ; 
+C 114 ; WX 525 ; N r ; B 32 0 487 437 ; 
+C 115 ; WX 525 ; N s ; B 72 -6 459 440 ; 
+C 116 ; WX 525 ; N t ; B 25 -6 449 554 ; 
+C 117 ; WX 525 ; N u ; B 12 -6 512 431 ; 
+C 118 ; WX 525 ; N v ; B 24 -4 500 431 ; 
+C 119 ; WX 525 ; N w ; B 16 -4 508 431 ; 
+C 120 ; WX 525 ; N x ; B 27 0 496 431 ; 
+C 121 ; WX 525 ; N y ; B 26 -228 500 431 ; 
+C 122 ; WX 525 ; N z ; B 33 0 475 431 ; 
+C 123 ; WX 525 ; N braceleft ; B 57 -83 467 694 ; 
+C 124 ; WX 525 ; N bar ; B 227 -83 297 694 ; 
+C 125 ; WX 525 ; N braceright ; B 57 -83 467 694 ; 
+C 126 ; WX 525 ; N asciitilde ; B 87 491 437 611 ; 
+C 127 ; WX 525 ; N dieresis ; B 110 512 414 612 ; 
+C -1 ; WX 525 ; N space ; B 0 0 0 0 ; 
+EndCharMetrics
+EndFontMetrics

outputs/audit_venv/lib/python3.11/site-packages/matplotlib/mpl-data/fonts/afm/pagd8a.afm

@@ -0,0 +1,576 @@
+StartFontMetrics 2.0
+Comment Copyright (c) 1985, 1987, 1989, 1990, 1991 Adobe Systems Incorporated.  All Rights Reserved.
+Comment Creation Date: Mon Mar  4 13:46:34 1991
+Comment UniqueID 34370
+Comment VMusage 24954 31846
+FontName AvantGarde-Demi
+FullName ITC Avant Garde Gothic Demi
+FamilyName ITC Avant Garde Gothic
+Weight Demi
+ItalicAngle 0
+IsFixedPitch false
+FontBBox -123 -251 1222 1021
+UnderlinePosition -100
+UnderlineThickness 50
+Version 001.007
+Notice Copyright (c) 1985, 1987, 1989, 1990, 1991 Adobe Systems Incorporated.  All Rights Reserved.ITC Avant Garde Gothic is a registered trademark of International Typeface Corporation.
+EncodingScheme AdobeStandardEncoding
+CapHeight 740
+XHeight 555
+Ascender 740
+Descender -185
+StartCharMetrics 228
+C 32 ; WX 280 ; N space ; B 0 0 0 0 ;
+C 33 ; WX 280 ; N exclam ; B 73 0 206 740 ;
+C 34 ; WX 360 ; N quotedbl ; B 19 444 341 740 ;
+C 35 ; WX 560 ; N numbersign ; B 29 0 525 700 ;
+C 36 ; WX 560 ; N dollar ; B 58 -86 501 857 ;
+C 37 ; WX 860 ; N percent ; B 36 -15 822 755 ;
+C 38 ; WX 680 ; N ampersand ; B 34 -15 665 755 ;
+C 39 ; WX 280 ; N quoteright ; B 72 466 205 740 ;
+C 40 ; WX 380 ; N parenleft ; B 74 -157 350 754 ;
+C 41 ; WX 380 ; N parenright ; B 37 -157 313 754 ;
+C 42 ; WX 440 ; N asterisk ; B 67 457 374 755 ;
+C 43 ; WX 600 ; N plus ; B 48 0 552 506 ;
+C 44 ; WX 280 ; N comma ; B 73 -141 206 133 ;
+C 45 ; WX 420 ; N hyphen ; B 71 230 349 348 ;
+C 46 ; WX 280 ; N period ; B 73 0 206 133 ;
+C 47 ; WX 460 ; N slash ; B 6 -100 454 740 ;
+C 48 ; WX 560 ; N zero ; B 32 -15 529 755 ;
+C 49 ; WX 560 ; N one ; B 137 0 363 740 ;
+C 50 ; WX 560 ; N two ; B 36 0 523 755 ;
+C 51 ; WX 560 ; N three ; B 28 -15 532 755 ;
+C 52 ; WX 560 ; N four ; B 15 0 545 740 ;
+C 53 ; WX 560 ; N five ; B 25 -15 535 740 ;
+C 54 ; WX 560 ; N six ; B 23 -15 536 739 ;
+C 55 ; WX 560 ; N seven ; B 62 0 498 740 ;
+C 56 ; WX 560 ; N eight ; B 33 -15 527 755 ;
+C 57 ; WX 560 ; N nine ; B 24 0 537 754 ;
+C 58 ; WX 280 ; N colon ; B 73 0 206 555 ;
+C 59 ; WX 280 ; N semicolon ; B 73 -141 206 555 ;
+C 60 ; WX 600 ; N less ; B 46 -8 554 514 ;
+C 61 ; WX 600 ; N equal ; B 48 81 552 425 ;
+C 62 ; WX 600 ; N greater ; B 46 -8 554 514 ;
+C 63 ; WX 560 ; N question ; B 38 0 491 755 ;
+C 64 ; WX 740 ; N at ; B 50 -12 750 712 ;
+C 65 ; WX 740 ; N A ; B 7 0 732 740 ;
+C 66 ; WX 580 ; N B ; B 70 0 551 740 ;
+C 67 ; WX 780 ; N C ; B 34 -15 766 755 ;
+C 68 ; WX 700 ; N D ; B 63 0 657 740 ;
+C 69 ; WX 520 ; N E ; B 61 0 459 740 ;
+C 70 ; WX 480 ; N F ; B 61 0 438 740 ;
+C 71 ; WX 840 ; N G ; B 27 -15 817 755 ;
+C 72 ; WX 680 ; N H ; B 71 0 610 740 ;
+C 73 ; WX 280 ; N I ; B 72 0 209 740 ;
+C 74 ; WX 480 ; N J ; B 2 -15 409 740 ;
+C 75 ; WX 620 ; N K ; B 89 0 620 740 ;
+C 76 ; WX 440 ; N L ; B 72 0 435 740 ;
+C 77 ; WX 900 ; N M ; B 63 0 837 740 ;
+C 78 ; WX 740 ; N N ; B 70 0 671 740 ;
+C 79 ; WX 840 ; N O ; B 33 -15 807 755 ;
+C 80 ; WX 560 ; N P ; B 72 0 545 740 ;
+C 81 ; WX 840 ; N Q ; B 32 -15 824 755 ;
+C 82 ; WX 580 ; N R ; B 64 0 565 740 ;
+C 83 ; WX 520 ; N S ; B 12 -15 493 755 ;
+C 84 ; WX 420 ; N T ; B 6 0 418 740 ;
+C 85 ; WX 640 ; N U ; B 55 -15 585 740 ;
+C 86 ; WX 700 ; N V ; B 8 0 695 740 ;
+C 87 ; WX 900 ; N W ; B 7 0 899 740 ;
+C 88 ; WX 680 ; N X ; B 4 0 676 740 ;
+C 89 ; WX 620 ; N Y ; B -2 0 622 740 ;
+C 90 ; WX 500 ; N Z ; B 19 0 481 740 ;
+C 91 ; WX 320 ; N bracketleft ; B 66 -157 284 754 ;
+C 92 ; WX 640 ; N backslash ; B 96 -100 544 740 ;
+C 93 ; WX 320 ; N bracketright ; B 36 -157 254 754 ;
+C 94 ; WX 600 ; N asciicircum ; B 73 375 527 740 ;
+C 95 ; WX 500 ; N underscore ; B 0 -125 500 -75 ;
+C 96 ; WX 280 ; N quoteleft ; B 72 466 205 740 ;
+C 97 ; WX 660 ; N a ; B 27 -18 613 574 ;
+C 98 ; WX 660 ; N b ; B 47 -18 632 740 ;
+C 99 ; WX 640 ; N c ; B 37 -18 610 574 ;
+C 100 ; WX 660 ; N d ; B 34 -18 618 740 ;
+C 101 ; WX 640 ; N e ; B 31 -18 610 577 ;
+C 102 ; WX 280 ; N f ; B 15 0 280 755 ; L i fi ; L l fl ;
+C 103 ; WX 660 ; N g ; B 32 -226 623 574 ;
+C 104 ; WX 600 ; N h ; B 54 0 546 740 ;
+C 105 ; WX 240 ; N i ; B 53 0 186 740 ;
+C 106 ; WX 260 ; N j ; B 16 -185 205 740 ;
+C 107 ; WX 580 ; N k ; B 80 0 571 740 ;
+C 108 ; WX 240 ; N l ; B 54 0 187 740 ;
+C 109 ; WX 940 ; N m ; B 54 0 887 574 ;
+C 110 ; WX 600 ; N n ; B 54 0 547 574 ;
+C 111 ; WX 640 ; N o ; B 25 -18 615 574 ;
+C 112 ; WX 660 ; N p ; B 47 -185 629 574 ;
+C 113 ; WX 660 ; N q ; B 31 -185 613 574 ;
+C 114 ; WX 320 ; N r ; B 63 0 317 574 ;
+C 115 ; WX 440 ; N s ; B 19 -18 421 574 ;
+C 116 ; WX 300 ; N t ; B 21 0 299 740 ;
+C 117 ; WX 600 ; N u ; B 50 -18 544 555 ;
+C 118 ; WX 560 ; N v ; B 3 0 556 555 ;
+C 119 ; WX 800 ; N w ; B 11 0 789 555 ;
+C 120 ; WX 560 ; N x ; B 3 0 556 555 ;
+C 121 ; WX 580 ; N y ; B 8 -185 571 555 ;
+C 122 ; WX 460 ; N z ; B 20 0 442 555 ;
+C 123 ; WX 340 ; N braceleft ; B -3 -191 317 747 ;
+C 124 ; WX 600 ; N bar ; B 233 -100 366 740 ;
+C 125 ; WX 340 ; N braceright ; B 23 -191 343 747 ;
+C 126 ; WX 600 ; N asciitilde ; B 67 160 533 347 ;
+C 161 ; WX 280 ; N exclamdown ; B 74 -185 207 555 ;
+C 162 ; WX 560 ; N cent ; B 43 39 517 715 ;
+C 163 ; WX 560 ; N sterling ; B -2 0 562 755 ;
+C 164 ; WX 160 ; N fraction ; B -123 0 282 740 ;
+C 165 ; WX 560 ; N yen ; B -10 0 570 740 ;
+C 166 ; WX 560 ; N florin ; B 0 -151 512 824 ;
+C 167 ; WX 560 ; N section ; B 28 -158 530 755 ;
+C 168 ; WX 560 ; N currency ; B 27 69 534 577 ;
+C 169 ; WX 220 ; N quotesingle ; B 44 444 177 740 ;
+C 170 ; WX 480 ; N quotedblleft ; B 70 466 410 740 ;
+C 171 ; WX 460 ; N guillemotleft ; B 61 108 400 469 ;
+C 172 ; WX 240 ; N guilsinglleft ; B 50 108 190 469 ;
+C 173 ; WX 240 ; N guilsinglright ; B 50 108 190 469 ;
+C 174 ; WX 520 ; N fi ; B 25 0 461 755 ;
+C 175 ; WX 520 ; N fl ; B 25 0 461 755 ;
+C 177 ; WX 500 ; N endash ; B 35 230 465 348 ;
+C 178 ; WX 560 ; N dagger ; B 51 -142 509 740 ;
+C 179 ; WX 560 ; N daggerdbl ; B 51 -142 509 740 ;
+C 180 ; WX 280 ; N periodcentered ; B 73 187 206 320 ;
+C 182 ; WX 600 ; N paragraph ; B -7 -103 607 740 ;
+C 183 ; WX 600 ; N bullet ; B 148 222 453 532 ;
+C 184 ; WX 280 ; N quotesinglbase ; B 72 -141 205 133 ;
+C 185 ; WX 480 ; N quotedblbase ; B 70 -141 410 133 ;
+C 186 ; WX 480 ; N quotedblright ; B 70 466 410 740 ;
+C 187 ; WX 460 ; N guillemotright ; B 61 108 400 469 ;
+C 188 ; WX 1000 ; N ellipsis ; B 100 0 899 133 ;
+C 189 ; WX 1280 ; N perthousand ; B 36 -15 1222 755 ;
+C 191 ; WX 560 ; N questiondown ; B 68 -200 521 555 ;
+C 193 ; WX 420 ; N grave ; B 50 624 329 851 ;
+C 194 ; WX 420 ; N acute ; B 91 624 370 849 ;
+C 195 ; WX 540 ; N circumflex ; B 71 636 470 774 ;
+C 196 ; WX 480 ; N tilde ; B 44 636 437 767 ;
+C 197 ; WX 420 ; N macron ; B 72 648 349 759 ;
+C 198 ; WX 480 ; N breve ; B 42 633 439 770 ;
+C 199 ; WX 280 ; N dotaccent ; B 74 636 207 769 ;
+C 200 ; WX 500 ; N dieresis ; B 78 636 422 769 ;
+C 202 ; WX 360 ; N ring ; B 73 619 288 834 ;
+C 203 ; WX 340 ; N cedilla ; B 98 -251 298 6 ;
+C 205 ; WX 700 ; N hungarumlaut ; B 132 610 609 862 ;
+C 206 ; WX 340 ; N ogonek ; B 79 -195 262 9 ;
+C 207 ; WX 540 ; N caron ; B 71 636 470 774 ;
+C 208 ; WX 1000 ; N emdash ; B 35 230 965 348 ;
+C 225 ; WX 900 ; N AE ; B -5 0 824 740 ;
+C 227 ; WX 360 ; N ordfeminine ; B 19 438 334 755 ;
+C 232 ; WX 480 ; N Lslash ; B 26 0 460 740 ;
+C 233 ; WX 840 ; N Oslash ; B 33 -71 807 814 ;
+C 234 ; WX 1060 ; N OE ; B 37 -15 1007 755 ;
+C 235 ; WX 360 ; N ordmasculine ; B 23 438 338 755 ;
+C 241 ; WX 1080 ; N ae ; B 29 -18 1048 574 ;
+C 245 ; WX 240 ; N dotlessi ; B 53 0 186 555 ;
+C 248 ; WX 320 ; N lslash ; B 34 0 305 740 ;
+C 249 ; WX 660 ; N oslash ; B 35 -50 625 608 ;
+C 250 ; WX 1080 ; N oe ; B 30 -18 1050 574 ;
+C 251 ; WX 600 ; N germandbls ; B 51 -18 585 755 ;
+C -1 ; WX 640 ; N ecircumflex ; B 31 -18 610 774 ;
+C -1 ; WX 640 ; N edieresis ; B 31 -18 610 769 ;
+C -1 ; WX 660 ; N aacute ; B 27 -18 613 849 ;
+C -1 ; WX 740 ; N registered ; B -12 -12 752 752 ;
+C -1 ; WX 240 ; N icircumflex ; B -79 0 320 774 ;
+C -1 ; WX 600 ; N udieresis ; B 50 -18 544 769 ;
+C -1 ; WX 640 ; N ograve ; B 25 -18 615 851 ;
+C -1 ; WX 600 ; N uacute ; B 50 -18 544 849 ;
+C -1 ; WX 600 ; N ucircumflex ; B 50 -18 544 774 ;
+C -1 ; WX 740 ; N Aacute ; B 7 0 732 1019 ;
+C -1 ; WX 240 ; N igrave ; B -65 0 214 851 ;
+C -1 ; WX 280 ; N Icircumflex ; B -59 0 340 944 ;
+C -1 ; WX 640 ; N ccedilla ; B 37 -251 610 574 ;
+C -1 ; WX 660 ; N adieresis ; B 27 -18 613 769 ;
+C -1 ; WX 520 ; N Ecircumflex ; B 61 0 460 944 ;
+C -1 ; WX 440 ; N scaron ; B 19 -18 421 774 ;
+C -1 ; WX 660 ; N thorn ; B 47 -185 629 740 ;
+C -1 ; WX 1000 ; N trademark ; B 9 296 821 740 ;
+C -1 ; WX 640 ; N egrave ; B 31 -18 610 851 ;
+C -1 ; WX 336 ; N threesuperior ; B 8 287 328 749 ;
+C -1 ; WX 460 ; N zcaron ; B 20 0 455 774 ;
+C -1 ; WX 660 ; N atilde ; B 27 -18 613 767 ;
+C -1 ; WX 660 ; N aring ; B 27 -18 613 834 ;
+C -1 ; WX 640 ; N ocircumflex ; B 25 -18 615 774 ;
+C -1 ; WX 520 ; N Edieresis ; B 61 0 459 939 ;
+C -1 ; WX 840 ; N threequarters ; B 18 0 803 749 ;
+C -1 ; WX 580 ; N ydieresis ; B 8 -185 571 769 ;
+C -1 ; WX 580 ; N yacute ; B 8 -185 571 849 ;
+C -1 ; WX 240 ; N iacute ; B 26 0 305 849 ;
+C -1 ; WX 740 ; N Acircumflex ; B 7 0 732 944 ;
+C -1 ; WX 640 ; N Uacute ; B 55 -15 585 1019 ;
+C -1 ; WX 640 ; N eacute ; B 31 -18 610 849 ;
+C -1 ; WX 840 ; N Ograve ; B 33 -15 807 1021 ;
+C -1 ; WX 660 ; N agrave ; B 27 -18 613 851 ;
+C -1 ; WX 640 ; N Udieresis ; B 55 -15 585 939 ;
+C -1 ; WX 660 ; N acircumflex ; B 27 -18 613 774 ;
+C -1 ; WX 280 ; N Igrave ; B -45 0 234 1021 ;
+C -1 ; WX 336 ; N twosuperior ; B 13 296 322 749 ;
+C -1 ; WX 640 ; N Ugrave ; B 55 -15 585 1021 ;
+C -1 ; WX 840 ; N onequarter ; B 92 0 746 740 ;
+C -1 ; WX 640 ; N Ucircumflex ; B 55 -15 585 944 ;
+C -1 ; WX 520 ; N Scaron ; B 12 -15 493 944 ;
+C -1 ; WX 280 ; N Idieresis ; B -32 0 312 939 ;
+C -1 ; WX 240 ; N idieresis ; B -52 0 292 769 ;
+C -1 ; WX 520 ; N Egrave ; B 61 0 459 1021 ;
+C -1 ; WX 840 ; N Oacute ; B 33 -15 807 1019 ;
+C -1 ; WX 600 ; N divide ; B 48 -20 552 526 ;
+C -1 ; WX 740 ; N Atilde ; B 7 0 732 937 ;
+C -1 ; WX 740 ; N Aring ; B 7 0 732 969 ;
+C -1 ; WX 840 ; N Odieresis ; B 33 -15 807 939 ;
+C -1 ; WX 740 ; N Adieresis ; B 7 0 732 939 ;
+C -1 ; WX 740 ; N Ntilde ; B 70 0 671 937 ;
+C -1 ; WX 500 ; N Zcaron ; B 19 0 481 944 ;
+C -1 ; WX 560 ; N Thorn ; B 72 0 545 740 ;
+C -1 ; WX 280 ; N Iacute ; B 46 0 325 1019 ;
+C -1 ; WX 600 ; N plusminus ; B 48 -62 552 556 ;
+C -1 ; WX 600 ; N multiply ; B 59 12 541 494 ;
+C -1 ; WX 520 ; N Eacute ; B 61 0 459 1019 ;
+C -1 ; WX 620 ; N Ydieresis ; B -2 0 622 939 ;
+C -1 ; WX 336 ; N onesuperior ; B 72 296 223 740 ;
+C -1 ; WX 600 ; N ugrave ; B 50 -18 544 851 ;
+C -1 ; WX 600 ; N logicalnot ; B 48 108 552 425 ;
+C -1 ; WX 600 ; N ntilde ; B 54 0 547 767 ;
+C -1 ; WX 840 ; N Otilde ; B 33 -15 807 937 ;
+C -1 ; WX 640 ; N otilde ; B 25 -18 615 767 ;
+C -1 ; WX 780 ; N Ccedilla ; B 34 -251 766 755 ;
+C -1 ; WX 740 ; N Agrave ; B 7 0 732 1021 ;
+C -1 ; WX 840 ; N onehalf ; B 62 0 771 740 ;
+C -1 ; WX 742 ; N Eth ; B 25 0 691 740 ;
+C -1 ; WX 400 ; N degree ; B 57 426 343 712 ;
+C -1 ; WX 620 ; N Yacute ; B -2 0 622 1019 ;
+C -1 ; WX 840 ; N Ocircumflex ; B 33 -15 807 944 ;
+C -1 ; WX 640 ; N oacute ; B 25 -18 615 849 ;
+C -1 ; WX 576 ; N mu ; B 38 -187 539 555 ;
+C -1 ; WX 600 ; N minus ; B 48 193 552 313 ;
+C -1 ; WX 640 ; N eth ; B 27 -18 616 754 ;
+C -1 ; WX 640 ; N odieresis ; B 25 -18 615 769 ;
+C -1 ; WX 740 ; N copyright ; B -12 -12 752 752 ;
+C -1 ; WX 600 ; N brokenbar ; B 233 -100 366 740 ;
+EndCharMetrics
+StartKernData
+StartKernPairs 218
+
+KPX A y -50
+KPX A w -65
+KPX A v -70
+KPX A u -20
+KPX A quoteright -90
+KPX A Y -80
+KPX A W -60
+KPX A V -102
+KPX A U -40
+KPX A T -25
+KPX A Q -50
+KPX A O -50
+KPX A G -40
+KPX A C -40
+
+KPX B A -10
+
+KPX C A -40
+
+KPX D period -20
+KPX D comma -20
+KPX D Y -45
+KPX D W -25
+KPX D V -50
+KPX D A -50
+
+KPX F period -129
+KPX F e -20
+KPX F comma -162
+KPX F a -20
+KPX F A -75
+
+KPX G period -20
+KPX G comma -20
+KPX G Y -15
+
+KPX J period -15
+KPX J a -20
+KPX J A -30
+
+KPX K y -20
+KPX K u -15
+KPX K o -45
+KPX K e -40
+KPX K O -30
+
+KPX L y -23
+KPX L quoteright -30
+KPX L quotedblright -30
+KPX L Y -80
+KPX L W -55
+KPX L V -85
+KPX L T -46
+
+KPX O period -30
+KPX O comma -30
+KPX O Y -30
+KPX O X -30
+KPX O W -20
+KPX O V -45
+KPX O T -15
+KPX O A -60
+
+KPX P period -200
+KPX P o -20
+KPX P e -20
+KPX P comma -220
+KPX P a -20
+KPX P A -100
+
+KPX Q comma 20
+
+KPX R W 25
+KPX R V -10
+KPX R U 25
+KPX R T 40
+KPX R O 25
+
+KPX S comma 20
+
+KPX T y -10
+KPX T w -55
+KPX T u -46
+KPX T semicolon -29
+KPX T r -30
+KPX T period -91
+KPX T o -49
+KPX T hyphen -75
+KPX T e -49
+KPX T comma -82
+KPX T colon -15
+KPX T a -70
+KPX T O -15
+KPX T A -25
+
+KPX U period -20
+KPX U comma -20
+KPX U A -40
+
+KPX V u -55
+KPX V semicolon -33
+KPX V period -145
+KPX V o -101
+KPX V i -15
+KPX V hyphen -75
+KPX V e -101
+KPX V comma -145
+KPX V colon -18
+KPX V a -95
+KPX V O -45
+KPX V G -20
+KPX V A -102
+
+KPX W y -15
+KPX W u -30
+KPX W semicolon -33
+KPX W period -106
+KPX W o -46
+KPX W i -10
+KPX W hyphen -35
+KPX W e -47
+KPX W comma -106
+KPX W colon -15
+KPX W a -50
+KPX W O -20
+KPX W A -58
+
+KPX Y u -52
+KPX Y semicolon -23
+KPX Y period -145
+KPX Y o -89
+KPX Y hyphen -100
+KPX Y e -89
+KPX Y comma -145
+KPX Y colon -10
+KPX Y a -93
+KPX Y O -30
+KPX Y A -80
+
+KPX a t 5
+KPX a p 20
+KPX a b 5
+
+KPX b y -20
+KPX b v -20
+
+KPX c y -20
+KPX c l -15
+KPX c k -15
+
+KPX comma space -50
+KPX comma quoteright -70
+KPX comma quotedblright -70
+
+KPX e y -20
+KPX e x -20
+KPX e w -20
+KPX e v -20
+
+KPX f period -40
+KPX f o -20
+KPX f l -15
+KPX f i -15
+KPX f f -20
+KPX f dotlessi -15
+KPX f comma -40
+KPX f a -15
+
+KPX g i 25
+KPX g a 15
+
+KPX h y -30
+
+KPX k y -5
+KPX k o -30
+KPX k e -40
+
+KPX m y -20
+KPX m u -20
+
+KPX n y -15
+KPX n v -30
+
+KPX o y -20
+KPX o x -30
+KPX o w -20
+KPX o v -30
+
+KPX p y -20
+
+KPX period space -50
+KPX period quoteright -70
+KPX period quotedblright -70
+
+KPX quotedblleft A -50
+
+KPX quotedblright space -50
+
+KPX quoteleft quoteleft -80
+KPX quoteleft A -50
+
+KPX quoteright v -10
+KPX quoteright t 10
+KPX quoteright space -50
+KPX quoteright s -15
+KPX quoteright r -20
+KPX quoteright quoteright -80
+KPX quoteright d -50
+
+KPX r y 40
+KPX r v 40
+KPX r u 20
+KPX r t 20
+KPX r s 20
+KPX r q -8
+KPX r period -73
+KPX r p 20
+KPX r o -15
+KPX r n 21
+KPX r m 15
+KPX r l 20
+KPX r k 5
+KPX r i 20
+KPX r hyphen -60
+KPX r g 1
+KPX r e -4
+KPX r d -6
+KPX r comma -75
+KPX r c -7
+
+KPX s period 20
+KPX s comma 20
+
+KPX space quoteleft -50
+KPX space quotedblleft -50
+KPX space Y -60
+KPX space W -25
+KPX space V -80
+KPX space T -25
+KPX space A -20
+
+KPX v period -90
+KPX v o -20
+KPX v e -20
+KPX v comma -90
+KPX v a -30
+
+KPX w period -90
+KPX w o -30
+KPX w e -20
+KPX w comma -90
+KPX w a -30
+
+KPX x e -20
+
+KPX y period -100
+KPX y o -30
+KPX y e -20
+KPX y comma -100
+KPX y c -35
+KPX y a -30
+EndKernPairs
+EndKernData
+StartComposites 56
+CC Aacute 2 ; PCC A 0 0 ; PCC acute 160 170 ;
+CC Acircumflex 2 ; PCC A 0 0 ; PCC circumflex 100 170 ;
+CC Adieresis 2 ; PCC A 0 0 ; PCC dieresis 120 170 ;
+CC Agrave 2 ; PCC A 0 0 ; PCC grave 160 170 ;
+CC Aring 2 ; PCC A 0 0 ; PCC ring 190 135 ;
+CC Atilde 2 ; PCC A 0 0 ; PCC tilde 130 170 ;
+CC Eacute 2 ; PCC E 0 0 ; PCC acute 50 170 ;
+CC Ecircumflex 2 ; PCC E 0 0 ; PCC circumflex -10 170 ;
+CC Edieresis 2 ; PCC E 0 0 ; PCC dieresis 10 170 ;
+CC Egrave 2 ; PCC E 0 0 ; PCC grave 50 170 ;
+CC Iacute 2 ; PCC I 0 0 ; PCC acute -45 170 ;
+CC Icircumflex 2 ; PCC I 0 0 ; PCC circumflex -130 170 ;
+CC Idieresis 2 ; PCC I 0 0 ; PCC dieresis -110 170 ;
+CC Igrave 2 ; PCC I 0 0 ; PCC grave -95 170 ;
+CC Ntilde 2 ; PCC N 0 0 ; PCC tilde 130 170 ;
+CC Oacute 2 ; PCC O 0 0 ; PCC acute 210 170 ;
+CC Ocircumflex 2 ; PCC O 0 0 ; PCC circumflex 150 170 ;
+CC Odieresis 2 ; PCC O 0 0 ; PCC dieresis 170 170 ;
+CC Ograve 2 ; PCC O 0 0 ; PCC grave 210 170 ;
+CC Otilde 2 ; PCC O 0 0 ; PCC tilde 180 170 ;
+CC Scaron 2 ; PCC S 0 0 ; PCC caron -10 170 ;
+CC Uacute 2 ; PCC U 0 0 ; PCC acute 145 170 ;
+CC Ucircumflex 2 ; PCC U 0 0 ; PCC circumflex 50 170 ;
+CC Udieresis 2 ; PCC U 0 0 ; PCC dieresis 70 170 ;
+CC Ugrave 2 ; PCC U 0 0 ; PCC grave 75 170 ;
+CC Yacute 2 ; PCC Y 0 0 ; PCC acute 135 170 ;
+CC Ydieresis 2 ; PCC Y 0 0 ; PCC dieresis 60 170 ;
+CC Zcaron 2 ; PCC Z 0 0 ; PCC caron 5 170 ;
+CC aacute 2 ; PCC a 0 0 ; PCC acute 120 0 ;
+CC acircumflex 2 ; PCC a 0 0 ; PCC circumflex 60 0 ;
+CC adieresis 2 ; PCC a 0 0 ; PCC dieresis 80 0 ;
+CC agrave 2 ; PCC a 0 0 ; PCC grave 120 0 ;
+CC aring 2 ; PCC a 0 0 ; PCC ring 150 0 ;
+CC atilde 2 ; PCC a 0 0 ; PCC tilde 90 0 ;
+CC eacute 2 ; PCC e 0 0 ; PCC acute 110 0 ;
+CC ecircumflex 2 ; PCC e 0 0 ; PCC circumflex 50 0 ;
+CC edieresis 2 ; PCC e 0 0 ; PCC dieresis 70 0 ;
+CC egrave 2 ; PCC e 0 0 ; PCC grave 110 0 ;
+CC iacute 2 ; PCC dotlessi 0 0 ; PCC acute -65 0 ;
+CC icircumflex 2 ; PCC dotlessi 0 0 ; PCC circumflex -150 0 ;
+CC idieresis 2 ; PCC dotlessi 0 0 ; PCC dieresis -130 0 ;
+CC igrave 2 ; PCC dotlessi 0 0 ; PCC grave -115 0 ;
+CC ntilde 2 ; PCC n 0 0 ; PCC tilde 60 0 ;
+CC oacute 2 ; PCC o 0 0 ; PCC acute 110 0 ;
+CC ocircumflex 2 ; PCC o 0 0 ; PCC circumflex 50 0 ;
+CC odieresis 2 ; PCC o 0 0 ; PCC dieresis 70 0 ;
+CC ograve 2 ; PCC o 0 0 ; PCC grave 110 0 ;
+CC otilde 2 ; PCC o 0 0 ; PCC tilde 80 0 ;
+CC scaron 2 ; PCC s 0 0 ; PCC caron -50 0 ;
+CC uacute 2 ; PCC u 0 0 ; PCC acute 125 0 ;
+CC ucircumflex 2 ; PCC u 0 0 ; PCC circumflex 30 0 ;
+CC udieresis 2 ; PCC u 0 0 ; PCC dieresis 50 0 ;
+CC ugrave 2 ; PCC u 0 0 ; PCC grave 55 0 ;
+CC yacute 2 ; PCC y 0 0 ; PCC acute 115 0 ;
+CC ydieresis 2 ; PCC y 0 0 ; PCC dieresis 40 0 ;
+CC zcaron 2 ; PCC z 0 0 ; PCC caron -15 0 ;
+EndComposites
+EndFontMetrics