Add files using upload-large-folder tool

.gitattributes

@@ -750,3 +750,4 @@ phi4/lib/python3.10/site-packages/pycparser/__pycache__/yacctab.cpython-310.pyc
 phi4/lib/python3.10/site-packages/torch/_refs/__pycache__/__init__.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 phi4/lib/python3.10/site-packages/torchvision.libs/libwebp.54a0d02a.so.7 filter=lfs diff=lfs merge=lfs -text
 phi4/lib/python3.10/site-packages/torchvision.libs/libjpeg.1c1c4b09.so.8 filter=lfs diff=lfs merge=lfs -text
+openflamingo/lib/python3.10/site-packages/pip/_vendor/distlib/w64-arm.exe filter=lfs diff=lfs merge=lfs -text

openflamingo/lib/python3.10/site-packages/click-8.1.8.dist-info/LICENSE.txt

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

openflamingo/lib/python3.10/site-packages/click-8.1.8.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.3
+Name: click
+Version: 8.1.8
+Summary: Composable command line interface toolkit
+Maintainer-email: Pallets <contact@palletsprojects.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Typing :: Typed
+Requires-Dist: colorama; platform_system == 'Windows'
+Requires-Dist: importlib-metadata; python_version < '3.8'
+Project-URL: Changes, https://click.palletsprojects.com/changes/
+Project-URL: Chat, https://discord.gg/pallets
+Project-URL: Documentation, https://click.palletsprojects.com/
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Source, https://github.com/pallets/click/
+
+# $ click_
+
+Click is a Python package for creating beautiful command line interfaces
+in a composable way with as little code as necessary. It's the "Command
+Line Interface Creation Kit". It's highly configurable but comes with
+sensible defaults out of the box.
+
+It aims to make the process of writing command line tools quick and fun
+while also preventing any frustration caused by the inability to
+implement an intended CLI API.
+
+Click in three points:
+
+-   Arbitrary nesting of commands
+-   Automatic help page generation
+-   Supports lazy loading of subcommands at runtime
+
+
+## A Simple Example
+
+```python
+import click
+
+@click.command()
+@click.option("--count", default=1, help="Number of greetings.")
+@click.option("--name", prompt="Your name", help="The person to greet.")
+def hello(count, name):
+    """Simple program that greets NAME for a total of COUNT times."""
+    for _ in range(count):
+        click.echo(f"Hello, {name}!")
+
+if __name__ == '__main__':
+    hello()
+```
+
+```
+$ python hello.py --count=3
+Your name: Click
+Hello, Click!
+Hello, Click!
+Hello, Click!
+```
+
+
+## Donate
+
+The Pallets organization develops and supports Click and other popular
+packages. In order to grow the community of contributors and users, and
+allow the maintainers to devote more time to the projects, [please
+donate today][].
+
+[please donate today]: https://palletsprojects.com/donate
+

openflamingo/lib/python3.10/site-packages/click-8.1.8.dist-info/RECORD

@@ -0,0 +1,39 @@
+click-8.1.8.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+click-8.1.8.dist-info/LICENSE.txt,sha256=morRBqOU6FO_4h9C9OctWSgZoigF2ZG18ydQKSkrZY0,1475
+click-8.1.8.dist-info/METADATA,sha256=WJtQ6uGS2ybLfvUE4vC0XIhIBr4yFGwjrMBR2fiCQ-Q,2263
+click-8.1.8.dist-info/RECORD,,
+click-8.1.8.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+click-8.1.8.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+click/__init__.py,sha256=j1DJeCbga4ribkv5uyvIAzI0oFN13fW9mevDKShFelo,3188
+click/__pycache__/__init__.cpython-310.pyc,,
+click/__pycache__/_compat.cpython-310.pyc,,
+click/__pycache__/_termui_impl.cpython-310.pyc,,
+click/__pycache__/_textwrap.cpython-310.pyc,,
+click/__pycache__/_winconsole.cpython-310.pyc,,
+click/__pycache__/core.cpython-310.pyc,,
+click/__pycache__/decorators.cpython-310.pyc,,
+click/__pycache__/exceptions.cpython-310.pyc,,
+click/__pycache__/formatting.cpython-310.pyc,,
+click/__pycache__/globals.cpython-310.pyc,,
+click/__pycache__/parser.cpython-310.pyc,,
+click/__pycache__/shell_completion.cpython-310.pyc,,
+click/__pycache__/termui.cpython-310.pyc,,
+click/__pycache__/testing.cpython-310.pyc,,
+click/__pycache__/types.cpython-310.pyc,,
+click/__pycache__/utils.cpython-310.pyc,,
+click/_compat.py,sha256=IGKh_J5QdfKELitnRfTGHneejWxoCw_NX9tfMbdcg3w,18730
+click/_termui_impl.py,sha256=a5z7I9gOFeMmu7Gb6_RPyQ8GPuVP1EeblixcWSPSQPk,24783
+click/_textwrap.py,sha256=10fQ64OcBUMuK7mFvh8363_uoOxPlRItZBmKzRJDgoY,1353
+click/_winconsole.py,sha256=5ju3jQkcZD0W27WEMGqmEP4y_crUVzPCqsX_FYb7BO0,7860
+click/core.py,sha256=Q1nEVdctZwvIPOlt4vfHko0TYnHCeE40UEEul8Wpyvs,114748
+click/decorators.py,sha256=7t6F-QWowtLh6F_6l-4YV4Y4yNTcqFQEu9i37zIz68s,18925
+click/exceptions.py,sha256=V7zDT6emqJ8iNl0kF1P5kpFmLMWQ1T1L7aNNKM4YR0w,9600
+click/formatting.py,sha256=Frf0-5W33-loyY_i9qrwXR8-STnW3m5gvyxLVUdyxyk,9706
+click/globals.py,sha256=cuJ6Bbo073lgEEmhjr394PeM-QFmXM-Ci-wmfsd7H5g,1954
+click/parser.py,sha256=h4sndcpF5OHrZQN8vD8IWb5OByvW7ABbhRToxovrqS8,19067
+click/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+click/shell_completion.py,sha256=TR0dXEGcvWb9Eo3aaQEXGhnvNS3FF4H4QcuLnvAvYo4,18636
+click/termui.py,sha256=dLxiS70UOvIYBda_nEEZaPAFOVDVmRs1sEPMuLDowQo,28310
+click/testing.py,sha256=3RA8anCf7TZ8-5RAF5it2Te-aWXBAL5VLasQnMiC2ZQ,16282
+click/types.py,sha256=BD5Qqq4h-8kawBmOIzJlmq4xzThAf4wCvaOLZSBDNx0,36422
+click/utils.py,sha256=ce-IrO9ilII76LGkU354pOdHbepM8UftfNH7SfMU_28,20330

openflamingo/lib/python3.10/site-packages/filelock/_util.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import os
+import stat
+import sys
+from errno import EACCES, EISDIR
+from pathlib import Path
+
+
+def raise_on_not_writable_file(filename: str) -> None:
+    """
+    Raise an exception if attempting to open the file for writing would fail.
+
+    This is done so files that will never be writable can be separated from files that are writable but currently
+    locked.
+
+    :param filename: file to check
+    :raises OSError: as if the file was opened for writing.
+
+    """
+    try:  # use stat to do exists + can write to check without race condition
+        file_stat = os.stat(filename)  # noqa: PTH116
+    except OSError:
+        return  # swallow does not exist or other errors
+
+    if file_stat.st_mtime != 0:  # if os.stat returns but modification is zero that's an invalid os.stat - ignore it
+        if not (file_stat.st_mode & stat.S_IWUSR):
+            raise PermissionError(EACCES, "Permission denied", filename)
+
+        if stat.S_ISDIR(file_stat.st_mode):
+            if sys.platform == "win32":  # pragma: win32 cover
+                # On Windows, this is PermissionError
+                raise PermissionError(EACCES, "Permission denied", filename)
+            else:  # pragma: win32 no cover # noqa: RET506
+                # On linux / macOS, this is IsADirectoryError
+                raise IsADirectoryError(EISDIR, "Is a directory", filename)
+
+
+def ensure_directory_exists(filename: Path | str) -> None:
+    """
+    Ensure the directory containing the file exists (create it if necessary).
+
+    :param filename: file.
+
+    """
+    Path(filename).parent.mkdir(parents=True, exist_ok=True)
+
+
+__all__ = [
+    "ensure_directory_exists",
+    "raise_on_not_writable_file",
+]

openflamingo/lib/python3.10/site-packages/markupsafe/_native.py

@@ -0,0 +1,8 @@
+def _escape_inner(s: str, /) -> str:
+    return (
+        s.replace("&", "&")
+        .replace(">", ">")
+        .replace("<", "&lt;")
+        .replace("'", "&#39;")
+        .replace('"', "&#34;")
+    )

openflamingo/lib/python3.10/site-packages/markupsafe/_speedups.c

@@ -0,0 +1,204 @@
+#include <Python.h>
+
+#define GET_DELTA(inp, inp_end, delta) \
+	while (inp < inp_end) { \
+		switch (*inp++) { \
+		case '"': \
+		case '\'': \
+		case '&': \
+			delta += 4; \
+			break; \
+		case '<': \
+		case '>': \
+			delta += 3; \
+			break; \
+		} \
+	}
+
+#define DO_ESCAPE(inp, inp_end, outp) \
+	{ \
+		Py_ssize_t ncopy = 0; \
+		while (inp < inp_end) { \
+			switch (*inp) { \
+			case '"': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = '#'; \
+				*outp++ = '3'; \
+				*outp++ = '4'; \
+				*outp++ = ';'; \
+				break; \
+			case '\'': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = '#'; \
+				*outp++ = '3'; \
+				*outp++ = '9'; \
+				*outp++ = ';'; \
+				break; \
+			case '&': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = 'a'; \
+				*outp++ = 'm'; \
+				*outp++ = 'p'; \
+				*outp++ = ';'; \
+				break; \
+			case '<': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = 'l'; \
+				*outp++ = 't'; \
+				*outp++ = ';'; \
+				break; \
+			case '>': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = 'g'; \
+				*outp++ = 't'; \
+				*outp++ = ';'; \
+				break; \
+			default: \
+				ncopy++; \
+			} \
+			inp++; \
+		} \
+		memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+	}
+
+static PyObject*
+escape_unicode_kind1(PyUnicodeObject *in)
+{
+	Py_UCS1 *inp = PyUnicode_1BYTE_DATA(in);
+	Py_UCS1 *inp_end = inp + PyUnicode_GET_LENGTH(in);
+	Py_UCS1 *outp;
+	PyObject *out;
+	Py_ssize_t delta = 0;
+
+	GET_DELTA(inp, inp_end, delta);
+	if (!delta) {
+		Py_INCREF(in);
+		return (PyObject*)in;
+	}
+
+	out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta,
+						PyUnicode_IS_ASCII(in) ? 127 : 255);
+	if (!out)
+		return NULL;
+
+	inp = PyUnicode_1BYTE_DATA(in);
+	outp = PyUnicode_1BYTE_DATA(out);
+	DO_ESCAPE(inp, inp_end, outp);
+	return out;
+}
+
+static PyObject*
+escape_unicode_kind2(PyUnicodeObject *in)
+{
+	Py_UCS2 *inp = PyUnicode_2BYTE_DATA(in);
+	Py_UCS2 *inp_end = inp + PyUnicode_GET_LENGTH(in);
+	Py_UCS2 *outp;
+	PyObject *out;
+	Py_ssize_t delta = 0;
+
+	GET_DELTA(inp, inp_end, delta);
+	if (!delta) {
+		Py_INCREF(in);
+		return (PyObject*)in;
+	}
+
+	out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta, 65535);
+	if (!out)
+		return NULL;
+
+	inp = PyUnicode_2BYTE_DATA(in);
+	outp = PyUnicode_2BYTE_DATA(out);
+	DO_ESCAPE(inp, inp_end, outp);
+	return out;
+}
+
+
+static PyObject*
+escape_unicode_kind4(PyUnicodeObject *in)
+{
+	Py_UCS4 *inp = PyUnicode_4BYTE_DATA(in);
+	Py_UCS4 *inp_end = inp + PyUnicode_GET_LENGTH(in);
+	Py_UCS4 *outp;
+	PyObject *out;
+	Py_ssize_t delta = 0;
+
+	GET_DELTA(inp, inp_end, delta);
+	if (!delta) {
+		Py_INCREF(in);
+		return (PyObject*)in;
+	}
+
+	out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta, 1114111);
+	if (!out)
+		return NULL;
+
+	inp = PyUnicode_4BYTE_DATA(in);
+	outp = PyUnicode_4BYTE_DATA(out);
+	DO_ESCAPE(inp, inp_end, outp);
+	return out;
+}
+
+static PyObject*
+escape_unicode(PyObject *self, PyObject *s)
+{
+	if (!PyUnicode_Check(s))
+		return NULL;
+
+    // This check is no longer needed in Python 3.12.
+	if (PyUnicode_READY(s))
+		return NULL;
+
+	switch (PyUnicode_KIND(s)) {
+	case PyUnicode_1BYTE_KIND:
+		return escape_unicode_kind1((PyUnicodeObject*) s);
+	case PyUnicode_2BYTE_KIND:
+		return escape_unicode_kind2((PyUnicodeObject*) s);
+	case PyUnicode_4BYTE_KIND:
+		return escape_unicode_kind4((PyUnicodeObject*) s);
+	}
+	assert(0);  /* shouldn't happen */
+	return NULL;
+}
+
+static PyMethodDef module_methods[] = {
+	{"_escape_inner", (PyCFunction)escape_unicode, METH_O, NULL},
+	{NULL, NULL, 0, NULL}  /* Sentinel */
+};
+
+static struct PyModuleDef module_definition = {
+	PyModuleDef_HEAD_INIT,
+	"markupsafe._speedups",
+	NULL,
+	-1,
+	module_methods,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+PyMODINIT_FUNC
+PyInit__speedups(void)
+{
+	PyObject *m = PyModule_Create(&module_definition);
+
+	if (m == NULL) {
+		return NULL;
+	}
+
+	#ifdef Py_GIL_DISABLED
+	PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+	#endif
+
+	return m;
+}

openflamingo/lib/python3.10/site-packages/markupsafe/_speedups.pyi

@@ -0,0 +1 @@
+def _escape_inner(s: str, /) -> str: ...

openflamingo/lib/python3.10/site-packages/matplotlib-3.9.4.dist-info/LICENSE

@@ -0,0 +1,99 @@
+License agreement for matplotlib versions 1.3.0 and later
+=========================================================
+
+1. This LICENSE AGREEMENT is between the Matplotlib Development Team
+("MDT"), and the Individual or Organization ("Licensee") accessing and
+otherwise using matplotlib software in source or binary form and its
+associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, MDT
+hereby grants Licensee a nonexclusive, royalty-free, world-wide license
+to reproduce, analyze, test, perform and/or display publicly, prepare
+derivative works, distribute, and otherwise use matplotlib
+alone or in any derivative version, provided, however, that MDT's
+License Agreement and MDT's notice of copyright, i.e., "Copyright (c)
+2012- Matplotlib Development Team; All Rights Reserved" are retained in
+matplotlib  alone or in any derivative version prepared by
+Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on or
+incorporates matplotlib or any part thereof, and wants to
+make the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to matplotlib .
+
+4. MDT is making matplotlib available to Licensee on an "AS
+IS" basis.  MDT MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, MDT MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB
+WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. MDT SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB
+ FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR
+LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING
+MATPLOTLIB , OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF
+THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between MDT and
+Licensee.  This License Agreement does not grant permission to use MDT
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using matplotlib ,
+Licensee agrees to be bound by the terms and conditions of this License
+Agreement.
+
+License agreement for matplotlib versions prior to 1.3.0
+========================================================
+
+1. This LICENSE AGREEMENT is between John D. Hunter ("JDH"), and the
+Individual or Organization ("Licensee") accessing and otherwise using
+matplotlib software in source or binary form and its associated
+documentation.
+
+2. Subject to the terms and conditions of this License Agreement, JDH
+hereby grants Licensee a nonexclusive, royalty-free, world-wide license
+to reproduce, analyze, test, perform and/or display publicly, prepare
+derivative works, distribute, and otherwise use matplotlib
+alone or in any derivative version, provided, however, that JDH's
+License Agreement and JDH's notice of copyright, i.e., "Copyright (c)
+2002-2011 John D. Hunter; All Rights Reserved" are retained in
+matplotlib  alone or in any derivative version prepared by
+Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on or
+incorporates matplotlib  or any part thereof, and wants to
+make the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to matplotlib.
+
+4. JDH is making matplotlib  available to Licensee on an "AS
+IS" basis.  JDH MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, JDH MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB
+WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. JDH SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB
+ FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR
+LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING
+MATPLOTLIB , OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF
+THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between JDH and
+Licensee.  This License Agreement does not grant permission to use JDH
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using matplotlib,
+Licensee agrees to be bound by the terms and conditions of this License
+Agreement.

openflamingo/lib/python3.10/site-packages/matplotlib-3.9.4.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.1
+Name: matplotlib
+Version: 3.9.4
+Summary: Python plotting package
+Author: John D. Hunter, Michael Droettboom
+Author-Email: Unknown <matplotlib-users@python.org>
+License: License agreement for matplotlib versions 1.3.0 and later
+         =========================================================
+         
+         1. This LICENSE AGREEMENT is between the Matplotlib Development Team
+         ("MDT"), and the Individual or Organization ("Licensee") accessing and
+         otherwise using matplotlib software in source or binary form and its
+         associated documentation.
+         
+         2. Subject to the terms and conditions of this License Agreement, MDT
+         hereby grants Licensee a nonexclusive, royalty-free, world-wide license
+         to reproduce, analyze, test, perform and/or display publicly, prepare
+         derivative works, distribute, and otherwise use matplotlib
+         alone or in any derivative version, provided, however, that MDT's
+         License Agreement and MDT's notice of copyright, i.e., "Copyright (c)
+         2012- Matplotlib Development Team; All Rights Reserved" are retained in
+         matplotlib  alone or in any derivative version prepared by
+         Licensee.
+         
+         3. In the event Licensee prepares a derivative work that is based on or
+         incorporates matplotlib or any part thereof, and wants to
+         make the derivative work available to others as provided herein, then
+         Licensee hereby agrees to include in any such work a brief summary of
+         the changes made to matplotlib .
+         
+         4. MDT is making matplotlib available to Licensee on an "AS
+         IS" basis.  MDT MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+         IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, MDT MAKES NO AND
+         DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+         FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB
+         WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+         
+         5. MDT SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB
+          FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR
+         LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING
+         MATPLOTLIB , OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF
+         THE POSSIBILITY THEREOF.
+         
+         6. This License Agreement will automatically terminate upon a material
+         breach of its terms and conditions.
+         
+         7. Nothing in this License Agreement shall be deemed to create any
+         relationship of agency, partnership, or joint venture between MDT and
+         Licensee.  This License Agreement does not grant permission to use MDT
+         trademarks or trade name in a trademark sense to endorse or promote
+         products or services of Licensee, or any third party.
+         
+         8. By copying, installing or otherwise using matplotlib ,
+         Licensee agrees to be bound by the terms and conditions of this License
+         Agreement.
+         
+         License agreement for matplotlib versions prior to 1.3.0
+         ========================================================
+         
+         1. This LICENSE AGREEMENT is between John D. Hunter ("JDH"), and the
+         Individual or Organization ("Licensee") accessing and otherwise using
+         matplotlib software in source or binary form and its associated
+         documentation.
+         
+         2. Subject to the terms and conditions of this License Agreement, JDH
+         hereby grants Licensee a nonexclusive, royalty-free, world-wide license
+         to reproduce, analyze, test, perform and/or display publicly, prepare
+         derivative works, distribute, and otherwise use matplotlib
+         alone or in any derivative version, provided, however, that JDH's
+         License Agreement and JDH's notice of copyright, i.e., "Copyright (c)
+         2002-2011 John D. Hunter; All Rights Reserved" are retained in
+         matplotlib  alone or in any derivative version prepared by
+         Licensee.
+         
+         3. In the event Licensee prepares a derivative work that is based on or
+         incorporates matplotlib  or any part thereof, and wants to
+         make the derivative work available to others as provided herein, then
+         Licensee hereby agrees to include in any such work a brief summary of
+         the changes made to matplotlib.
+         
+         4. JDH is making matplotlib  available to Licensee on an "AS
+         IS" basis.  JDH MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+         IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, JDH MAKES NO AND
+         DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+         FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB
+         WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+         
+         5. JDH SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB
+          FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR
+         LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING
+         MATPLOTLIB , OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF
+         THE POSSIBILITY THEREOF.
+         
+         6. This License Agreement will automatically terminate upon a material
+         breach of its terms and conditions.
+         
+         7. Nothing in this License Agreement shall be deemed to create any
+         relationship of agency, partnership, or joint venture between JDH and
+         Licensee.  This License Agreement does not grant permission to use JDH
+         trademarks or trade name in a trademark sense to endorse or promote
+         products or services of Licensee, or any third party.
+         
+         8. By copying, installing or otherwise using matplotlib,
+         Licensee agrees to be bound by the terms and conditions of this License
+         Agreement.
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Matplotlib
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: Python Software Foundation License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Project-URL: Homepage, https://matplotlib.org
+Project-URL: Download, https://matplotlib.org/stable/install/index.html
+Project-URL: Documentation, https://matplotlib.org
+Project-URL: Source Code, https://github.com/matplotlib/matplotlib
+Project-URL: Bug Tracker, https://github.com/matplotlib/matplotlib/issues
+Project-URL: Forum, https://discourse.matplotlib.org/
+Project-URL: Donate, https://numfocus.org/donate-to-matplotlib
+Requires-Python: >=3.9
+Requires-Dist: contourpy>=1.0.1
+Requires-Dist: cycler>=0.10
+Requires-Dist: fonttools>=4.22.0
+Requires-Dist: kiwisolver>=1.3.1
+Requires-Dist: numpy>=1.23
+Requires-Dist: packaging>=20.0
+Requires-Dist: pillow>=8
+Requires-Dist: pyparsing>=2.3.1
+Requires-Dist: python-dateutil>=2.7
+Requires-Dist: importlib-resources>=3.2.0; python_version < "3.10"
+Provides-Extra: dev
+Requires-Dist: meson-python<0.17.0,>=0.13.1; extra == "dev"
+Requires-Dist: numpy>=1.25; extra == "dev"
+Requires-Dist: pybind11!=2.13.3,>=2.6; extra == "dev"
+Requires-Dist: setuptools_scm>=7; extra == "dev"
+Requires-Dist: setuptools>=64; extra == "dev"
+Description-Content-Type: text/markdown
+
+[![PyPi](https://img.shields.io/pypi/v/matplotlib)](https://pypi.org/project/matplotlib/)
+[![Conda](https://img.shields.io/conda/vn/conda-forge/matplotlib)](https://anaconda.org/conda-forge/matplotlib)
+[![Downloads](https://img.shields.io/pypi/dm/matplotlib)](https://pypi.org/project/matplotlib)
+[![NUMFocus](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
+
+[![Discourse help forum](https://img.shields.io/badge/help_forum-discourse-blue.svg)](https://discourse.matplotlib.org)
+[![Gitter](https://badges.gitter.im/matplotlib/matplotlib.svg)](https://gitter.im/matplotlib/matplotlib)
+[![GitHub issues](https://img.shields.io/badge/issue_tracking-github-blue.svg)](https://github.com/matplotlib/matplotlib/issues)
+[![Contributing](https://img.shields.io/badge/PR-Welcome-%23FF8300.svg?)](https://matplotlib.org/stable/devel/index.html)
+
+[![GitHub actions status](https://github.com/matplotlib/matplotlib/workflows/Tests/badge.svg)](https://github.com/matplotlib/matplotlib/actions?query=workflow%3ATests)
+[![Azure pipelines status](https://dev.azure.com/matplotlib/matplotlib/_apis/build/status/matplotlib.matplotlib?branchName=main)](https://dev.azure.com/matplotlib/matplotlib/_build/latest?definitionId=1&branchName=main)
+[![AppVeyor status](https://ci.appveyor.com/api/projects/status/github/matplotlib/matplotlib?branch=main&svg=true)](https://ci.appveyor.com/project/matplotlib/matplotlib)
+[![Codecov status](https://codecov.io/github/matplotlib/matplotlib/badge.svg?branch=main&service=github)](https://app.codecov.io/gh/matplotlib/matplotlib)
+[![EffVer Versioning](https://img.shields.io/badge/version_scheme-EffVer-0097a7)](https://jacobtomlinson.dev/effver)
+
+![Matplotlib logotype](https://matplotlib.org/_static/logo2.svg)
+
+Matplotlib is a comprehensive library for creating static, animated, and
+interactive visualizations in Python.
+
+Check out our [home page](https://matplotlib.org/) for more information.
+
+![image](https://matplotlib.org/_static/readme_preview.png)
+
+Matplotlib produces publication-quality figures in a variety of hardcopy
+formats and interactive environments across platforms. Matplotlib can be
+used in Python scripts, Python/IPython shells, web application servers,
+and various graphical user interface toolkits.
+
+## Install
+
+See the [install
+documentation](https://matplotlib.org/stable/users/installing/index.html),
+which is generated from `/doc/install/index.rst`
+
+## Contribute
+
+You've discovered a bug or something else you want to change — excellent!
+
+You've worked out a way to fix it — even better!
+
+You want to tell us about it — best of all!
+
+Start at the [contributing
+guide](https://matplotlib.org/devdocs/devel/contribute.html)!
+
+## Contact
+
+[Discourse](https://discourse.matplotlib.org/) is the discussion forum
+for general questions and discussions and our recommended starting
+point.
+
+Our active mailing lists (which are mirrored on Discourse) are:
+
+-   [Users](https://mail.python.org/mailman/listinfo/matplotlib-users)
+    mailing list: <matplotlib-users@python.org>
+-   [Announcement](https://mail.python.org/mailman/listinfo/matplotlib-announce)
+    mailing list: <matplotlib-announce@python.org>
+-   [Development](https://mail.python.org/mailman/listinfo/matplotlib-devel)
+    mailing list: <matplotlib-devel@python.org>
+
+[Gitter](https://gitter.im/matplotlib/matplotlib) is for coordinating
+development and asking questions directly related to contributing to
+matplotlib.
+
+## Citing Matplotlib
+
+If Matplotlib contributes to a project that leads to publication, please
+acknowledge this by citing Matplotlib.
+
+[A ready-made citation
+entry](https://matplotlib.org/stable/users/project/citing.html) is
+available.

openflamingo/lib/python3.10/site-packages/matplotlib-3.9.4.dist-info/RECORD

@@ -0,0 +1,873 @@
+__pycache__/pylab.cpython-310.pyc,,
+matplotlib-3.9.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+matplotlib-3.9.4.dist-info/LICENSE,sha256=WhqB6jAXKMi7opM9qDLAzWIina8giToCSrPVMkRGjbw,4830
+matplotlib-3.9.4.dist-info/METADATA,sha256=ei7sI7VELRyseI8MJff12QoQybf3yGH-T685ZHK6oAI,11423
+matplotlib-3.9.4.dist-info/RECORD,,
+matplotlib-3.9.4.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+matplotlib-3.9.4.dist-info/WHEEL,sha256=sZM_NeUMz2G4fDenMf11eikcCxcLaQWiYRmjwQBavQs,137
+matplotlib/__init__.py,sha256=WeSzQt08wYslOiH6cuPHIqKTkC0Xw6sCeFTlH3QCTgw,53928
+matplotlib/__init__.pyi,sha256=NPwMLxwar4wyMqXAMU_p_Wo3ea4xHJ1LrtZ_trNFFo8,2992
+matplotlib/__pycache__/__init__.cpython-310.pyc,,
+matplotlib/__pycache__/_afm.cpython-310.pyc,,
+matplotlib/__pycache__/_animation_data.cpython-310.pyc,,
+matplotlib/__pycache__/_blocking_input.cpython-310.pyc,,
+matplotlib/__pycache__/_cm.cpython-310.pyc,,
+matplotlib/__pycache__/_cm_listed.cpython-310.pyc,,
+matplotlib/__pycache__/_color_data.cpython-310.pyc,,
+matplotlib/__pycache__/_constrained_layout.cpython-310.pyc,,
+matplotlib/__pycache__/_docstring.cpython-310.pyc,,
+matplotlib/__pycache__/_enums.cpython-310.pyc,,
+matplotlib/__pycache__/_fontconfig_pattern.cpython-310.pyc,,
+matplotlib/__pycache__/_internal_utils.cpython-310.pyc,,
+matplotlib/__pycache__/_layoutgrid.cpython-310.pyc,,
+matplotlib/__pycache__/_mathtext.cpython-310.pyc,,
+matplotlib/__pycache__/_mathtext_data.cpython-310.pyc,,
+matplotlib/__pycache__/_pylab_helpers.cpython-310.pyc,,
+matplotlib/__pycache__/_text_helpers.cpython-310.pyc,,
+matplotlib/__pycache__/_tight_bbox.cpython-310.pyc,,
+matplotlib/__pycache__/_tight_layout.cpython-310.pyc,,
+matplotlib/__pycache__/_type1font.cpython-310.pyc,,
+matplotlib/__pycache__/_version.cpython-310.pyc,,
+matplotlib/__pycache__/animation.cpython-310.pyc,,
+matplotlib/__pycache__/artist.cpython-310.pyc,,
+matplotlib/__pycache__/axis.cpython-310.pyc,,
+matplotlib/__pycache__/backend_bases.cpython-310.pyc,,
+matplotlib/__pycache__/backend_managers.cpython-310.pyc,,
+matplotlib/__pycache__/backend_tools.cpython-310.pyc,,
+matplotlib/__pycache__/bezier.cpython-310.pyc,,
+matplotlib/__pycache__/category.cpython-310.pyc,,
+matplotlib/__pycache__/cbook.cpython-310.pyc,,
+matplotlib/__pycache__/cm.cpython-310.pyc,,
+matplotlib/__pycache__/collections.cpython-310.pyc,,
+matplotlib/__pycache__/colorbar.cpython-310.pyc,,
+matplotlib/__pycache__/colors.cpython-310.pyc,,
+matplotlib/__pycache__/container.cpython-310.pyc,,
+matplotlib/__pycache__/contour.cpython-310.pyc,,
+matplotlib/__pycache__/dates.cpython-310.pyc,,
+matplotlib/__pycache__/dviread.cpython-310.pyc,,
+matplotlib/__pycache__/figure.cpython-310.pyc,,
+matplotlib/__pycache__/font_manager.cpython-310.pyc,,
+matplotlib/__pycache__/gridspec.cpython-310.pyc,,
+matplotlib/__pycache__/hatch.cpython-310.pyc,,
+matplotlib/__pycache__/image.cpython-310.pyc,,
+matplotlib/__pycache__/layout_engine.cpython-310.pyc,,
+matplotlib/__pycache__/legend.cpython-310.pyc,,
+matplotlib/__pycache__/legend_handler.cpython-310.pyc,,
+matplotlib/__pycache__/lines.cpython-310.pyc,,
+matplotlib/__pycache__/markers.cpython-310.pyc,,
+matplotlib/__pycache__/mathtext.cpython-310.pyc,,
+matplotlib/__pycache__/mlab.cpython-310.pyc,,
+matplotlib/__pycache__/offsetbox.cpython-310.pyc,,
+matplotlib/__pycache__/patches.cpython-310.pyc,,
+matplotlib/__pycache__/path.cpython-310.pyc,,
+matplotlib/__pycache__/patheffects.cpython-310.pyc,,
+matplotlib/__pycache__/pylab.cpython-310.pyc,,
+matplotlib/__pycache__/pyplot.cpython-310.pyc,,
+matplotlib/__pycache__/quiver.cpython-310.pyc,,
+matplotlib/__pycache__/rcsetup.cpython-310.pyc,,
+matplotlib/__pycache__/sankey.cpython-310.pyc,,
+matplotlib/__pycache__/scale.cpython-310.pyc,,
+matplotlib/__pycache__/spines.cpython-310.pyc,,
+matplotlib/__pycache__/stackplot.cpython-310.pyc,,
+matplotlib/__pycache__/streamplot.cpython-310.pyc,,
+matplotlib/__pycache__/table.cpython-310.pyc,,
+matplotlib/__pycache__/texmanager.cpython-310.pyc,,
+matplotlib/__pycache__/text.cpython-310.pyc,,
+matplotlib/__pycache__/textpath.cpython-310.pyc,,
+matplotlib/__pycache__/ticker.cpython-310.pyc,,
+matplotlib/__pycache__/transforms.cpython-310.pyc,,
+matplotlib/__pycache__/typing.cpython-310.pyc,,
+matplotlib/__pycache__/units.cpython-310.pyc,,
+matplotlib/__pycache__/widgets.cpython-310.pyc,,
+matplotlib/_afm.py,sha256=cWe1Ib37T6ZyHbR6_hPuzAjotMmi32y-kDB-i28iyqE,16692
+matplotlib/_animation_data.py,sha256=JJJbbc-fMdPjkbQ7ng9BHL5i91VTDHQVTtEdWOvWBAI,7986
+matplotlib/_api/__init__.py,sha256=FKsAM4RckCyJZiL-yXI1NRsvQxvbxxzSgvv8xpaX0I0,13304
+matplotlib/_api/__init__.pyi,sha256=9xxTTkE9MIP4xFNwmRvM9j0QflFrqcFbowCAedGhdqo,2254
+matplotlib/_api/__pycache__/__init__.cpython-310.pyc,,
+matplotlib/_api/__pycache__/deprecation.cpython-310.pyc,,
+matplotlib/_api/deprecation.py,sha256=F3IonykeAhU1z8N2ViqBEtPWWa1YDCYccmdl0CkgIEw,20027
+matplotlib/_api/deprecation.pyi,sha256=a9djyVvnX2-t-IGrk3z1mrnYHcj4qYxRD0n9KDHWXlE,2208
+matplotlib/_blocking_input.py,sha256=VHNsxvX2mTx_xBknd30MSicVlRXS4dCDe9hDctbV5rk,1224
+matplotlib/_c_internal_utils.cpython-310-x86_64-linux-gnu.so,sha256=ZDwgjzyxQELgtvPYKqMfsJT8VvYb7s7gqrAAHMRFgKs,251392
+matplotlib/_c_internal_utils.pyi,sha256=Z3bLs9pMGXrmZjt-4_A-x4321bLP-B54xDbr4PIgUfc,377
+matplotlib/_cm.py,sha256=uxuEdcEkReRPOYpRCcRrCfsbl1N1T5l8QtnId3xnGUU,67190
+matplotlib/_cm_listed.py,sha256=hpgMx7bjxJx5nl1PbQvaCDUBHQf8njaRrM2iMaBeZOM,109462
+matplotlib/_color_data.py,sha256=k-wdTi6ArJxksqBfMT-7Uy2qWz8XX4Th5gsjf32CwmM,34780
+matplotlib/_color_data.pyi,sha256=RdBRk01yuf3jYVlCwG351tIBCxehizkZMnKs9c8gnOw,170
+matplotlib/_constrained_layout.py,sha256=zBx9pT8lIlOXrFb-K-8HSk_jjqFy-wwZsFf6z8SECnw,31003
+matplotlib/_docstring.py,sha256=nPXtBXXO8doLznC_hkaf2OOiVZBQm-1TE-uA_KdtOAQ,3936
+matplotlib/_docstring.pyi,sha256=YjWQjaiffjCBVQpNbI1lsuiUUBBD5HSSEOV2xKD1_KA,741
+matplotlib/_enums.py,sha256=cq5dtb_qy4g3cHgr1KdVA9qzYalgz7KCtTytyFp3PAs,6474
+matplotlib/_enums.pyi,sha256=B5MhNYWDyhVZteR5lo9uRJ8RiduSGKrYw1NkBTT8Mx4,364
+matplotlib/_fontconfig_pattern.py,sha256=2livocARMbpys8tmicH6wlifcwcNoIstgruSY6DSAfk,4361
+matplotlib/_image.cpython-310-x86_64-linux-gnu.so,sha256=2ctP80bF6Pas1A4OoNEn0bPCJY4f3oIbSs57xNPtnxU,550744
+matplotlib/_image.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+matplotlib/_internal_utils.py,sha256=nhK6LLWYW93fBcsFiO09JmqFj2rgHEsGYFOeaC7HRKw,2140
+matplotlib/_layoutgrid.py,sha256=mFB9asZVol2aV9hLBpdntuG5x1isKUrajF-3TUhCgso,21676
+matplotlib/_mathtext.py,sha256=vVdbDoXC1lYioFO45cftsASoT4Re74rdREkUW0YNDfY,107860
+matplotlib/_mathtext_data.py,sha256=Odf6FpGVC-ARfVIRokBl1qG_tvnAzWmCtdFICk0N9hc,65133
+matplotlib/_path.cpython-310-x86_64-linux-gnu.so,sha256=_jRuGlfdk5gnjeRWv5kP2aVjEFJxhtJzzZOIbcnT3aI,472824
+matplotlib/_path.pyi,sha256=yznyfzoUogH9vvi0vK68ga4Shlbrn5UBhAnLX8Ght1o,325
+matplotlib/_pylab_helpers.py,sha256=9EyocyQhnPvsSzIvbthznz6wlIa74i94WSnja1vKi0U,4306
+matplotlib/_pylab_helpers.pyi,sha256=7OZKr-OL3ipVt1EDZ6e-tRwHASz-ijYfcIdlPczXhvQ,1012
+matplotlib/_qhull.cpython-310-x86_64-linux-gnu.so,sha256=8RL7aYZmfgOLNoz6u3zu5Hm0PFz97AJeIts6sQyqfxU,745280
+matplotlib/_qhull.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+matplotlib/_text_helpers.py,sha256=Eowfk0L2lBmYjMk2wCYJseoBCMR6odSM2f5xOTe6j7k,2543
+matplotlib/_tight_bbox.py,sha256=ddJ5ViXulbPLocHr-RkWK27WJSuV2WXUx74jZyL0NOg,2787
+matplotlib/_tight_layout.py,sha256=A3vZKBmxci7w35OO9lxgfUqrRKgTr-N_dUza0M05WxE,12675
+matplotlib/_tri.cpython-310-x86_64-linux-gnu.so,sha256=bYvYkQloF5Jdj-fGD_Wa7JOwIq-D6SK1QPrBmOpK-z8,411032
+matplotlib/_tri.pyi,sha256=yUtwM4BGi_KjvDY6CT8-Pafi8mfKLJtqLMmwK0xNJkQ,1026
+matplotlib/_ttconv.cpython-310-x86_64-linux-gnu.so,sha256=EPAvLhk1V0xP2Fgr_6CcKXGZV1szOQukl_n-ciQjiK0,293432
+matplotlib/_ttconv.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+matplotlib/_type1font.py,sha256=c_PXvyOFQ4YCRQJ23snWNkdEhuZ4k0JbLe55zaeoXfQ,28409
+matplotlib/_version.py,sha256=XbkIFAFwsSJjopCLi4Ne4fIKWso2YG0VKjrtMTj1ZNc,18
+matplotlib/animation.py,sha256=VSvfWiByVrNGEdwsLdQb3Bn0YXNjhbEamoK0ibTmsB0,71071
+matplotlib/animation.pyi,sha256=C8Fgmswh4um-qYgqPZNBEpXVaefRXi6e026pYjonLHg,6566
+matplotlib/artist.py,sha256=PkkMaP_yg33K8Yukf-p3mJcsF8CRPAtB8z2U3qfTnf4,63724
+matplotlib/artist.pyi,sha256=cNZ0vUZYz6GjJ-CYe80M7koriHlCcvojmOn26qC6T6E,6870
+matplotlib/axes/__init__.py,sha256=M5qLawRtk4NWxZ2Hf9ohCM7Lm4qvbMy77VFebKCvvsk,365
+matplotlib/axes/__init__.pyi,sha256=HP1z2v-PboHQS4dQjvJ7XjUjX-zw6taZRTTB9oVKwYE,303
+matplotlib/axes/__pycache__/__init__.cpython-310.pyc,,
+matplotlib/axes/__pycache__/_axes.cpython-310.pyc,,
+matplotlib/axes/__pycache__/_base.cpython-310.pyc,,
+matplotlib/axes/__pycache__/_secondary_axes.cpython-310.pyc,,
+matplotlib/axes/_axes.py,sha256=4DnKP8g4s7U0uBlQPEynl35WfRYWsxRO6AuwGhIeMZk,342358
+matplotlib/axes/_axes.pyi,sha256=V87WHlXhbMI7JuLpAkbGBrAhMpdy--2wXKJMzcJRYSw,25588
+matplotlib/axes/_base.py,sha256=u3tSfBgYotdGMdK8IxxEAwTYV0IHIKrAdjEbMQD-2tc,182124
+matplotlib/axes/_base.pyi,sha256=BLC_FyXh8F0Eu_XIuPum4CY_sqcFbJL1vc8USCzMIek,17010
+matplotlib/axes/_secondary_axes.py,sha256=hg5ghWAcLe-XDgb66jaRnNau46fYW4nmeGKtANZ2Ygw,11867
+matplotlib/axes/_secondary_axes.pyi,sha256=GtU55YzLNN7XHMRQcAmcAxcdcN-FzHw1RAJpOiTcZFk,1414
+matplotlib/axis.py,sha256=9K96t3nvKMmR5CV_m2mmfYJ5fnnPXUkKWFI6uON_BWA,103108
+matplotlib/axis.pyi,sha256=v15ue_f2ZQNEFDrjsmRWc7tLoGOjHQEgBIU3vqcmqoU,10156
+matplotlib/backend_bases.py,sha256=tV4kREN0gxX9DFj6jM-G6HWs3DZhtnbdxnqyNwGkGfU,131593
+matplotlib/backend_bases.pyi,sha256=SsMxDsEGxWCtuFlIG11x1CCQy04tvnaszDeUn_jlhAY,16216
+matplotlib/backend_managers.py,sha256=RQheCO_cQBlaWsYMbAmswu0UPKU7bmLTI5LEFgotklA,11795
+matplotlib/backend_managers.pyi,sha256=agnuM0wiZRqSgqti2AgbKJijRLvEPNLOrSY8PEwLjFE,2253
+matplotlib/backend_tools.py,sha256=wXWJ5xLh7pCpbiGrLkJOeLAxE9f9_c0kdVTripfZaNY,33351
+matplotlib/backend_tools.pyi,sha256=Pt07U2m84j7PPH_iim0mwZtf9BUhOlQC3kqAV6oOuNM,4030
+matplotlib/backends/__init__.py,sha256=JowJe-tDrUBMNJTiJATgiEuACpgdxsKnRCYa-nC255A,206
+matplotlib/backends/__pycache__/__init__.cpython-310.pyc,,
+matplotlib/backends/__pycache__/_backend_gtk.cpython-310.pyc,,
+matplotlib/backends/__pycache__/_backend_pdf_ps.cpython-310.pyc,,
+matplotlib/backends/__pycache__/_backend_tk.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_agg.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_cairo.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_gtk3.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_gtk3agg.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_gtk3cairo.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_gtk4.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_gtk4agg.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_gtk4cairo.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_macosx.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_mixed.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_nbagg.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_pdf.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_pgf.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_ps.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_qt.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_qt5.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_qt5agg.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_qt5cairo.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_qtagg.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_qtcairo.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_svg.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_template.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_tkagg.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_tkcairo.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_webagg.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_webagg_core.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_wx.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_wxagg.cpython-310.pyc,,
+matplotlib/backends/__pycache__/backend_wxcairo.cpython-310.pyc,,
+matplotlib/backends/__pycache__/qt_compat.cpython-310.pyc,,
+matplotlib/backends/__pycache__/registry.cpython-310.pyc,,
+matplotlib/backends/_backend_agg.cpython-310-x86_64-linux-gnu.so,sha256=bwjszpFW1QMgS_SSKuxS43FzHoOP2hwo68nBNhgWWH4,418232
+matplotlib/backends/_backend_agg.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+matplotlib/backends/_backend_gtk.py,sha256=zNCmMOgjgZGfAIlxDU4ph02XMSSn0wIUoPQ4wsaeeAg,11274
+matplotlib/backends/_backend_pdf_ps.py,sha256=E799e3XOJ5mp6YoecWp63xDS-DGqFLd4JfsGc0tMLRI,4444
+matplotlib/backends/_backend_tk.py,sha256=zVr77hxmEutHx9obexgG_gROu2lMlZIkhNk387e6grE,42222
+matplotlib/backends/_macosx.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+matplotlib/backends/_tkagg.cpython-310-x86_64-linux-gnu.so,sha256=lfIaA2808i5va3qzhvEyIWJmCbEDAHxgmTB4Npv_CRA,279032
+matplotlib/backends/_tkagg.pyi,sha256=1yKnYKSgNFesrb0ZI5RQCyTO4zONgHW5MrJ9vq4HzyI,379
+matplotlib/backends/backend_agg.py,sha256=wkhS9W2QBjGdIYU27hDXJu-MXRh4dB0_itGMBjkGWfQ,20434
+matplotlib/backends/backend_cairo.py,sha256=Ah5M85Ppa8zYGOtLOizW0gzltjs3b4nD56qFeQR795U,18618
+matplotlib/backends/backend_gtk3.py,sha256=xhjmb15l_9dnlU5aLfEcbh6s16t5uopIZEEgJtOSANg,21644
+matplotlib/backends/backend_gtk3agg.py,sha256=LzA-FwoCKrBIu4v-PJHuqx3HWK-4OM7wuujyyl8EWnI,2465
+matplotlib/backends/backend_gtk3cairo.py,sha256=zPsJzVm750if2LiQ9ybzsbX0rBhkP05XVvR9Lhz65so,1392
+matplotlib/backends/backend_gtk4.py,sha256=m-GqRG7YTsQhfIK2TOn5rii2LhnInW5M_Y-0kpNWWiY,21170
+matplotlib/backends/backend_gtk4agg.py,sha256=00i3qpIt9Tcf_S74GOWbeckiPlfVJoQ2pBbhXDMthF0,1262
+matplotlib/backends/backend_gtk4cairo.py,sha256=sqWm3WgfNO8EsBjqzsD4U4cAc0f4q5SufYx7ZJacDf0,1125
+matplotlib/backends/backend_macosx.py,sha256=MYeU1HyVwdIotSYuNcu4c18_gOgX4AnCU061DIvw1X8,7373
+matplotlib/backends/backend_mixed.py,sha256=PAYTjNuunpAa4-JkBguvyOjgDlB0eg9ARDAWidKfJpc,4698
+matplotlib/backends/backend_nbagg.py,sha256=Au9RHfRufpI0ngT4R0K0CUVtAMFi9Bg-YhDunlj_Lko,8000
+matplotlib/backends/backend_pdf.py,sha256=5Qxe_nG5JW3G9bZXaeab6CtOMeb8WNUmQjekWARk4iY,105846
+matplotlib/backends/backend_pgf.py,sha256=_MZKA2sWAvoCIkz9YEuAxMPS5EaIkx41-mVpqQ-S54c,39660
+matplotlib/backends/backend_ps.py,sha256=o43IOl5SEx_oBbO8EBX-ihlD-aYfsK9hIvSho5GWxTE,47465
+matplotlib/backends/backend_qt.py,sha256=EEFQiRkGsc_Ja-RP22MorQZkT_qHJ_7Vrq9goiC_CuU,41321
+matplotlib/backends/backend_qt5.py,sha256=kzfoo2ksEGsiWAa2LGtZYzKvfzqJJWyGOohohcRAu1g,787
+matplotlib/backends/backend_qt5agg.py,sha256=Vh7H8kqWH4X8a3VX2XZ2Vze9srwJavkNHAZxdJUz_bk,352
+matplotlib/backends/backend_qt5cairo.py,sha256=Go2Y0GVkXh1xh6x4F255_e5Xbwwws-OiD1Fc0805E78,292
+matplotlib/backends/backend_qtagg.py,sha256=ZjPtp5wR6tZGjbngPXRdVXYRhiPPrc5C0q2DmtdRkpY,3413
+matplotlib/backends/backend_qtcairo.py,sha256=e3SUG50VGqo68eS_8ebTCVQPa4AaxLxuo1JiWX4TIWg,1770
+matplotlib/backends/backend_svg.py,sha256=2EH6dGrDBJvHmW0MC51-2q8Sbtj8iAs1SlpVpjHH-WU,50078
+matplotlib/backends/backend_template.py,sha256=Z352VD5tp_xsNcR-DQcqt-LOB8lXoNzkCzFaMZaS0Dg,8010
+matplotlib/backends/backend_tkagg.py,sha256=z9gB16fq2d-DUNpbeSDDLWaYmc0Jz3cDqNlBKhnQg0c,592
+matplotlib/backends/backend_tkcairo.py,sha256=JaGGXh8Y5FwVZtgryIucN941Olf_Pn6f4Re7Vuxl1-c,845
+matplotlib/backends/backend_webagg.py,sha256=YzNscpsID8yu0XYO3NXiZLMPZnDKMAKdG_TO2Ya3g4k,11022
+matplotlib/backends/backend_webagg_core.py,sha256=7lcoinjD0fswQ1-acN5QOB1HJ6YoUgIZGrsmgZP5cl8,18303
+matplotlib/backends/backend_wx.py,sha256=Ph53LEd5HcT_YtPV_udrG3k7xnOn0LA5t1VxdbpGIVQ,50585
+matplotlib/backends/backend_wxagg.py,sha256=tzcwYyW34j4LPfHm9uhuHwepwZIcspi3y8oPC8FJkdk,1468
+matplotlib/backends/backend_wxcairo.py,sha256=TK-m3S0c1WipfKE2IpIPNeE4hoXPjfMvnWAzHpCXpFs,848
+matplotlib/backends/qt_compat.py,sha256=Ox7GVBb1BYvRLiyMt9w0qrisSA_Rqwq1BbEblSSYq2M,5340
+matplotlib/backends/qt_editor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+matplotlib/backends/qt_editor/__pycache__/__init__.cpython-310.pyc,,
+matplotlib/backends/qt_editor/__pycache__/_formlayout.cpython-310.pyc,,
+matplotlib/backends/qt_editor/__pycache__/figureoptions.cpython-310.pyc,,
+matplotlib/backends/qt_editor/_formlayout.py,sha256=QmqqqLO6waqeSGOKjDNUwjvon53Z7yqil5AfqfftDWY,20953
+matplotlib/backends/qt_editor/figureoptions.py,sha256=-0yrpqasVq2CtCw1gGnzPqQF6Zlj1H84krBo4AQ_RwE,9833
+matplotlib/backends/registry.py,sha256=l6CsAe3Y25HZpkNjFOjduEuVlB_Y2VWX5oCBd_xqVTg,15708
+matplotlib/backends/web_backend/all_figures.html,sha256=44Y-GvIJbNlqQaKSW3kwVKpTxBSG1WsdYz3ZmYHlUsA,1753
+matplotlib/backends/web_backend/css/boilerplate.css,sha256=qui16QXRnQFNJDbcMasfH6KtN9hLjv8883U9cJmsVCE,2310
+matplotlib/backends/web_backend/css/fbm.css,sha256=wa4vNkNv7fQ_TufjJjecFZEzPMR6W8x6uXJga_wQILw,1456
+matplotlib/backends/web_backend/css/mpl.css,sha256=ruca_aA5kNnP-MZmLkriu8teVP1nIgwcFEpoB16j8Z4,1611
+matplotlib/backends/web_backend/css/page.css,sha256=ca3nO3TaPw7865PN5SlGJBTc2H3rBXQCMaFPywX29y4,1623
+matplotlib/backends/web_backend/ipython_inline_figure.html,sha256=wgSxUh3xpPAxOnZgSMnrhDM5hYncOfWRGgaCUezvedY,1311
+matplotlib/backends/web_backend/js/mpl.js,sha256=nK4yXHi8DD8Oj0mlE_MZStFRH13-q67kFzlxpC_Sa-0,24376
+matplotlib/backends/web_backend/js/mpl_tornado.js,sha256=Zs2Uzs7YUilG765nYvanCo-IK8HkHDtIum1KAq6bQ_w,302
+matplotlib/backends/web_backend/js/nbagg_mpl.js,sha256=F-By4ZjOSmwpNAkxUUxUk35qCjGlf0B28Z0aOyfpxDM,9514
+matplotlib/backends/web_backend/single_figure.html,sha256=wEBwF602JLHErBUEXiS6jXqmxYAIzHpa3MMFrnev6rs,1357
+matplotlib/bezier.py,sha256=DMqrzM6Rc5g99UiKXsppoYI5Da5awrzYDCvDBOJzbNM,19049
+matplotlib/bezier.pyi,sha256=itubQt_U1IKnQ508bhy6J8LSpaspvZIeOmJqg7JvOmU,2586
+matplotlib/category.py,sha256=aDGxoBkadhun-NDpc4clsA2oHS7Ehqj2g2ApnUoV3Ig,7316
+matplotlib/cbook.py,sha256=x9ZWTaT6ke8vFfbGUMcZP7ofhqq5sgGKDNSfK35JlN4,79585
+matplotlib/cbook.pyi,sha256=pq3CtksIt6AoYEH3WCbHKUv-M2fgkXRNbWOqxnXCbTM,6412
+matplotlib/cm.py,sha256=N_v6hE1GTKeVqxR_Mfz5KyHeQNAMjCAIugnHAurXYFI,23745
+matplotlib/cm.pyi,sha256=bgZU7a6K512niO9Rf7VqijDXqewCZZ3PKgsualbKTz4,2079
+matplotlib/collections.py,sha256=sXK0PGHz162UlbWZbN7bNOiQbi00RvFZQkqLBL4gYxA,89127
+matplotlib/collections.pyi,sha256=q0jLo4iym3IS_QaShIUf7g540vJFvN3M8vbMVFL2U6A,9993
+matplotlib/colorbar.py,sha256=NS25-U7SbWw1LOfTWYht5HSy_0n9oMaJc_TDivUrgWc,60148
+matplotlib/colorbar.pyi,sha256=lXMHYAvr9GnXcHgpy40WumUaNjX9TiHhpdWTpBwEl50,4800
+matplotlib/colors.py,sha256=RdFmkCp7GaVo3L7FXOCEoNHZ41e-g6Xq8qrralWGMWY,102026
+matplotlib/colors.pyi,sha256=W7mMeE_PF2jv4VvTCaq9EVyeuZoY6SoutNI4Ema-uq8,11192
+matplotlib/container.py,sha256=Y6v4j79gMk8QDYfrdOqbbJHH0BoOIO9enz4dtlaBSJU,4565
+matplotlib/container.pyi,sha256=DdthHVj1-bQQV3VcpMD1uIPLXVUKyKhWMXy8yCniK1I,1805
+matplotlib/contour.py,sha256=O0EzECgbh-OmQ_6Hg0BRyoBfu8q6GHQypIN89DLd-U4,74733
+matplotlib/contour.pyi,sha256=cco-D_g83ajEC0_B38ECTI47F49k-RxMCbcN6qduumA,5973
+matplotlib/dates.py,sha256=fhN7zDua3xKIR-rbGdZMdANg0JZ2ry73rhfBPSr_hHc,66066
+matplotlib/dviread.py,sha256=dcj4b6SLvOH1JucVIdoSQ50Tyngpfr-TT-WS5SgUu4k,41366
+matplotlib/dviread.pyi,sha256=YZUFI3FQ2NDnodV7lCz9lAlsH0Yt0_mWMdZdmYOikHw,2197
+matplotlib/figure.py,sha256=dttHRXxMNryvkZPTrn0JVXh_11opiQmqog-nc8NIlvs,137818
+matplotlib/figure.pyi,sha256=CSPqZd36iQy-qbssqhCQizc40k6LabVJAvkfeJobEVA,14132
+matplotlib/font_manager.py,sha256=5jDy5aRDIn0Gr2DZw_OGnNgVqwxJWHQvcR6VCV8xqGg,55298
+matplotlib/font_manager.pyi,sha256=Jse1IshOdjhXHdjcvTxtos3rgsuECbRJzc264A-ZGus,5052
+matplotlib/ft2font.cpython-310-x86_64-linux-gnu.so,sha256=imyUm74qC-N4o_ciCRKgGc55W-UgW_5Q_zJrpqP1q-w,967848
+matplotlib/ft2font.pyi,sha256=4TEeRwvPFm2UyYdxx0z7fmJAdb7Jk_l7CFbP5FdqVms,7046
+matplotlib/gridspec.py,sha256=3_3f_mqb8au9U2CAcSE-VbQRPr_QjpMhfSGE3uxJJVg,29765
+matplotlib/gridspec.pyi,sha256=kGzdRdRag6vMMLXyB1JmMCULY9WX4acQaPb238h0yDw,5108
+matplotlib/hatch.py,sha256=xAHggohTuCv3ErJdISdTgmZhxhAFYFs3Petrqw84V7M,7450
+matplotlib/hatch.pyi,sha256=OEFkNe8TgrBli_MDMW99Tvhr44S4ySPaYQomjVXpUUA,2098
+matplotlib/image.py,sha256=rqMDIAnHyjI3tAkkZXi_s0BTn2yfPwp9IIsJCtQEvb0,71694
+matplotlib/image.pyi,sha256=y8hOWg1hQDm8r__6DlJUsX4_WvxA5uneilN9Th3s7_c,6812
+matplotlib/layout_engine.py,sha256=NOsx76R_jx7_94n8OeSgqo58A1Kmlmpc-YH0GePcY68,11248
+matplotlib/layout_engine.pyi,sha256=9cKFTFPCvwmKIygTUvrvOq1iWnFYme9Shniiv2QbC74,1788
+matplotlib/legend.py,sha256=13dPH2R0FAKwUBcq-NbYdPbYmOo6dUPAYccN9iOg-Bg,56015
+matplotlib/legend.pyi,sha256=hn-MNF3SPHtSUqIhwVXTebU_Nzk_wIh5iKgf7AEAZRg,5364
+matplotlib/legend_handler.py,sha256=CxW3PlOMhpU6Wnp0sI0NVXomLph5haHfC1l9e-m2kvo,29915
+matplotlib/legend_handler.pyi,sha256=3VEfeioGIAxhd3mhg4PXETZjCKf4OlXL0jz1MAFGtos,7655
+matplotlib/lines.py,sha256=5V3KKUMqz9fRsg4RCKFZoYMs5L6VgUiULI4mdc5pONM,56050
+matplotlib/lines.pyi,sha256=5RB6Fr5i67lRKqEiLNGIGRX5mtxT30nbt18WFrLsQao,6080
+matplotlib/markers.py,sha256=g6ukerZ5n_sD_Enk0eJA4kkTvOOp8AfSGBq60PHot-E,33708
+matplotlib/markers.pyi,sha256=FFFBsvilnbd8-5L04U70kfVoyBwc18w_fZ6DysTj9p0,1678
+matplotlib/mathtext.py,sha256=FRczaMkP8Y17aSxlekQG1xdVs-51bxbo3afREoi0U2M,4943
+matplotlib/mathtext.pyi,sha256=RCVxYGQ_CJ6wC7v_HkqoouU2PhtcvlJ1ffIyxzAC-so,1045
+matplotlib/mlab.py,sha256=6iTxX5xyc4NEPpTzBQwE_CF6mwS4ShytML87lYtlcmA,30236
+matplotlib/mlab.pyi,sha256=mkR7wbJS9eCQfCFsUWoXnqrAy0kcE3cVqpFZCeOGC_Q,3583
+matplotlib/mpl-data/fonts/afm/cmex10.afm,sha256=blR3ERmrVBV5XKkAnDCj4NMeYVgzH7cXtJ3u59u9GuE,12070
+matplotlib/mpl-data/fonts/afm/cmmi10.afm,sha256=5qwEOpedEo76bDUahyuuF1q0cD84tRrX-VQ4p3MlfBo,10416
+matplotlib/mpl-data/fonts/afm/cmr10.afm,sha256=WDvgC_D3UkGJg9u-J0U6RaT02lF4oz3lQxHtg1r3lYw,10101
+matplotlib/mpl-data/fonts/afm/cmsy10.afm,sha256=AbmzvCVWBceHRfmRfeJ9E6xzOQTFLk0U1zDfpf3_MaM,8295
+matplotlib/mpl-data/fonts/afm/cmtt10.afm,sha256=4ji7_mTpeWMa93o_UHBWPKCnqsBfhJJNllat1lJArP4,6501
+matplotlib/mpl-data/fonts/afm/pagd8a.afm,sha256=jjFrigwkTpYLqa26cpzZvKQNBo-PuF4bmDVqaM4pMWw,17183
+matplotlib/mpl-data/fonts/afm/pagdo8a.afm,sha256=sgNQdeYyx8J-itGw9h31y95aMBiTCRvmNSPTXwwS7xg,17255
+matplotlib/mpl-data/fonts/afm/pagk8a.afm,sha256=ZUtfHPloNqcvGMHMxaKDSlshhOcjwheUx143RwpGdIU,17241
+matplotlib/mpl-data/fonts/afm/pagko8a.afm,sha256=Yj1wBg6Jsqqz1KBfhRoJ3ACR-CMQol8Fj_ZM5NZ1gDk,17346
+matplotlib/mpl-data/fonts/afm/pbkd8a.afm,sha256=Zl5o6J_di9Y5j2EpHtjew-_sfg7-WoeVmO9PzOYSTUc,15157
+matplotlib/mpl-data/fonts/afm/pbkdi8a.afm,sha256=JAOno930iTyfZILMf11vWtiaTgrJcPpP6FRTRhEMMD4,15278
+matplotlib/mpl-data/fonts/afm/pbkl8a.afm,sha256=UJqJjOJ6xQDgDBLX157mKpohIJFVmHM-N6x2-DiGv14,15000
+matplotlib/mpl-data/fonts/afm/pbkli8a.afm,sha256=AWislZ2hDbs0ox_qOWREugsbS8_8lpL48LPMR40qpi0,15181
+matplotlib/mpl-data/fonts/afm/pcrb8a.afm,sha256=6j1TS2Uc7DWSc-8l42TGDc1u0Fg8JspeWfxFayjUwi8,15352
+matplotlib/mpl-data/fonts/afm/pcrbo8a.afm,sha256=smg3mjl9QaBDtQIt06ko5GvaxLsO9QtTvYANuE5hfG0,15422
+matplotlib/mpl-data/fonts/afm/pcrr8a.afm,sha256=7nxFr0Ehz4E5KG_zSE5SZOhxRH8MyfnCbw-7x5wu7tw,15339
+matplotlib/mpl-data/fonts/afm/pcrro8a.afm,sha256=NKEz7XtdFkh9cA8MvY-S3UOZlV2Y_J3tMEWFFxj7QSg,15443
+matplotlib/mpl-data/fonts/afm/phvb8a.afm,sha256=NAx4M4HjL7vANCJbc-tk04Vkol-T0oaXeQ3T2h-XUvM,17155
+matplotlib/mpl-data/fonts/afm/phvb8an.afm,sha256=8e_myD-AQkNF7q9XNLb2m76_lX2TUr3a5wog_LIE1sk,17086
+matplotlib/mpl-data/fonts/afm/phvbo8a.afm,sha256=8fkBRmJ-SWY2YrBg8fFyjJyrJp8daQ6JPO6LvhM8xPI,17230
+matplotlib/mpl-data/fonts/afm/phvbo8an.afm,sha256=aeVRvV4r15BBvxuRJ0MG8ZHuH2HViuIiCYkvuapmkmM,17195
+matplotlib/mpl-data/fonts/afm/phvl8a.afm,sha256=IyMYM-bgl-gI6rG0EuZZ2OLzlxJfGeSh8xqsh0t-eJQ,15627
+matplotlib/mpl-data/fonts/afm/phvlo8a.afm,sha256=s12C-eNnIDHJ_UVbuiprjxBjCiHIbS3Y8ORTC-qTpuI,15729
+matplotlib/mpl-data/fonts/afm/phvr8a.afm,sha256=Kt8KaRidts89EBIK29X2JomDUEDxvroeaJz_RNTi6r4,17839
+matplotlib/mpl-data/fonts/afm/phvr8an.afm,sha256=lL5fAHTRwODl-sB5mH7IfsD1tnnea4yRUK-_Ca2bQHM,17781
+matplotlib/mpl-data/fonts/afm/phvro8a.afm,sha256=3KqK3eejiR4hIFBUynuSX_4lMdE2V2T58xOF8lX-fwc,17919
+matplotlib/mpl-data/fonts/afm/phvro8an.afm,sha256=Vx9rRf3YfasMY7tz-njSxz67xHKk-fNkN7yBi0X2IP0,17877
+matplotlib/mpl-data/fonts/afm/pncb8a.afm,sha256=aoXepTcDQtQa_mspflMJkEFKefzXHoyjz6ioJVI0YNc,16028
+matplotlib/mpl-data/fonts/afm/pncbi8a.afm,sha256=pCWW1MYgy0EmvwaYsaYJaAI_LfrsKmDANHu7Pk0RaiU,17496
+matplotlib/mpl-data/fonts/afm/pncr8a.afm,sha256=0CIB2BLe9r-6_Wl5ObRTTf98UOrezmGQ8ZOuBX5kLks,16665
+matplotlib/mpl-data/fonts/afm/pncri8a.afm,sha256=5R-pLZOnaHNG8pjV6MP3Ai-d2OTQYR_cYCb5zQhzfSU,16920
+matplotlib/mpl-data/fonts/afm/pplb8a.afm,sha256=3EzUbNnXr5Ft5eFLY00W9oWu59rHORgDXUuJaOoKN58,15662
+matplotlib/mpl-data/fonts/afm/pplbi8a.afm,sha256=X_9tVspvrcMer3OS8qvdwjFFqpAXYZneyCL2NHA902g,15810
+matplotlib/mpl-data/fonts/afm/pplr8a.afm,sha256=ijMb497FDJ9nVdVMb21F7W3-cu9sb_9nF0oriFpSn8k,15752
+matplotlib/mpl-data/fonts/afm/pplri8a.afm,sha256=8KITbarcUUMi_hdoRLLmNHtlqs0TtOSKqtPFft7X5nY,15733
+matplotlib/mpl-data/fonts/afm/psyr.afm,sha256=Iyt8ajE4B2Tm34oBj2pKtctIf9kPfq05suQefq8p3Ro,9644
+matplotlib/mpl-data/fonts/afm/ptmb8a.afm,sha256=bL1fA1NC4_nW14Zrnxz4nHlXJb4dzELJPvodqKnYeMg,17983
+matplotlib/mpl-data/fonts/afm/ptmbi8a.afm,sha256=-_Ui6XlKaFTHEnkoS_-1GtIr5VtGa3gFQ2ezLOYHs08,18070
+matplotlib/mpl-data/fonts/afm/ptmr8a.afm,sha256=IEcsWcmzJyjCwkgsw4o6hIMmzlyXUglJat9s1PZNnEU,17942
+matplotlib/mpl-data/fonts/afm/ptmri8a.afm,sha256=49fQMg5fIGguZ7rgc_2styMK55Pv5bPTs7wCzqpcGpk,18068
+matplotlib/mpl-data/fonts/afm/putb8a.afm,sha256=qMaHTdpkrNL-m4DWhjpxJCSmgYkCv1qIzLlFfM0rl40,21532
+matplotlib/mpl-data/fonts/afm/putbi8a.afm,sha256=g7AVJyiTxeMpNk_1cSfmYgM09uNUfPlZyWGv3D1vcAk,21931
+matplotlib/mpl-data/fonts/afm/putr8a.afm,sha256=XYmNC5GQgSVAZKTIYdYeNksE6znNm9GF_0SmQlriqx0,22148
+matplotlib/mpl-data/fonts/afm/putri8a.afm,sha256=i7fVe-iLyLtQxCfAa4IxdxH-ufcHmMk7hbCGG5TxAY4,21891
+matplotlib/mpl-data/fonts/afm/pzcmi8a.afm,sha256=wyuoIWEZOcoXrSl1tPzLkEahik7kGi91JJj-tkFRG4A,16250
+matplotlib/mpl-data/fonts/afm/pzdr.afm,sha256=MyjLAnzKYRdQBfof1W3k_hf30MvqOkqL__G22mQ5xww,9467
+matplotlib/mpl-data/fonts/pdfcorefonts/Courier-Bold.afm,sha256=sIDDI-B82VZ3C0mI_mHFITCZ7PVn37AIYMv1CrHX4sE,15333
+matplotlib/mpl-data/fonts/pdfcorefonts/Courier-BoldOblique.afm,sha256=zg61QobD3YU9UBfCXmvmhBNaFKno-xj8sY0b2RpgfLw,15399
+matplotlib/mpl-data/fonts/pdfcorefonts/Courier-Oblique.afm,sha256=vRQm5j1sTUN4hicT1PcVZ9P9DTTUHhEzfPXqUUzVZhE,15441
+matplotlib/mpl-data/fonts/pdfcorefonts/Courier.afm,sha256=Mdcq2teZEBJrIqVXnsnhee7oZnTs6-P8_292kWGTrw4,15335
+matplotlib/mpl-data/fonts/pdfcorefonts/Helvetica-Bold.afm,sha256=i2l4gcjuYXoXf28uK7yIVwuf0rnw6J7PwPVQeHj5iPw,69269
+matplotlib/mpl-data/fonts/pdfcorefonts/Helvetica-BoldOblique.afm,sha256=Um5O6qK11DXLt8uj_0IoWkc84TKqHK3bObSKUswQqvY,69365
+matplotlib/mpl-data/fonts/pdfcorefonts/Helvetica-Oblique.afm,sha256=hVYDg2b52kqtbVeCzmiv25bW1yYdpkZS-LXlGREN2Rs,74392
+matplotlib/mpl-data/fonts/pdfcorefonts/Helvetica.afm,sha256=23cvKDD7bQAJB3kdjSahJSTZaUOppznlIO6FXGslyW8,74292
+matplotlib/mpl-data/fonts/pdfcorefonts/Symbol.afm,sha256=P5UaoXr4y0qh4SiMa5uqijDT6ZDr2-jPmj1ayry593E,9740
+matplotlib/mpl-data/fonts/pdfcorefonts/Times-Bold.afm,sha256=cQTmr2LFPwKQE_sGQageMcmFicjye16mKJslsJLHQyE,64251
+matplotlib/mpl-data/fonts/pdfcorefonts/Times-BoldItalic.afm,sha256=pzWOdycm6RqocBWgAVY5Jq0z3Fp7LuqWgLNMx4q6OFw,59642
+matplotlib/mpl-data/fonts/pdfcorefonts/Times-Italic.afm,sha256=bK5puSMpGT_YUILwyJrXoxjfj7XJOdfv5TQ_iKsJRzw,66328
+matplotlib/mpl-data/fonts/pdfcorefonts/Times-Roman.afm,sha256=hhNrUnpazuDDKD1WpraPxqPWCYLrO7D7bMVOg-zI13o,60460
+matplotlib/mpl-data/fonts/pdfcorefonts/ZapfDingbats.afm,sha256=ZuOmt9GcKofjdOq8kqhPhtAIhOwkL2rTJTmZxAjFakA,9527
+matplotlib/mpl-data/fonts/pdfcorefonts/readme.txt,sha256=MRv8ppSITYYAb7lt5EOw9DWWNZIblfxsFhu5TQE7cpI,828
+matplotlib/mpl-data/fonts/ttf/DejaVuSans-Bold.ttf,sha256=sYS4njwQdfIva3FXW2_CDUlys8_TsjMiym_Vltyu8Wc,704128
+matplotlib/mpl-data/fonts/ttf/DejaVuSans-BoldOblique.ttf,sha256=bt8CgxYBhq9FHL7nHnuEXy5Mq_Jku5ks5mjIPCVGXm8,641720
+matplotlib/mpl-data/fonts/ttf/DejaVuSans-Oblique.ttf,sha256=zN90s1DxH9PdV3TeUOXmNGoaXaH1t9X7g1kGZel6UhM,633840
+matplotlib/mpl-data/fonts/ttf/DejaVuSans.ttf,sha256=P99pyr8GBJ6nCgC1kZNA4s4ebQKwzDxLRPtoAb0eDSI,756072
+matplotlib/mpl-data/fonts/ttf/DejaVuSansDisplay.ttf,sha256=ggmdz7paqGjN_CdFGYlSX-MpL3N_s8ngMozpzvWWUvY,25712
+matplotlib/mpl-data/fonts/ttf/DejaVuSansMono-Bold.ttf,sha256=uq2ppRcv4giGJRr_BDP8OEYZEtXa8HKH577lZiCo2pY,331536
+matplotlib/mpl-data/fonts/ttf/DejaVuSansMono-BoldOblique.ttf,sha256=ppCBwVx2yCfgonpaf1x0thNchDSZlVSV_6jCDTqYKIs,253116
+matplotlib/mpl-data/fonts/ttf/DejaVuSansMono-Oblique.ttf,sha256=KAUoE_enCfyJ9S0ZLcmV708P3Fw9e3OknWhJsZFtDNA,251472
+matplotlib/mpl-data/fonts/ttf/DejaVuSansMono.ttf,sha256=YC7Ia4lIz82VZIL-ZPlMNshndwFJ7y95HUYT9EO87LM,340240
+matplotlib/mpl-data/fonts/ttf/DejaVuSerif-Bold.ttf,sha256=w3U_Lta8Zz8VhG3EWt2-s7nIcvMvsY_VOiHxvvHtdnY,355692
+matplotlib/mpl-data/fonts/ttf/DejaVuSerif-BoldItalic.ttf,sha256=2T7-x6nS6CZ2jRou6VuVhw4V4pWZqE80hK8d4c7C4YE,347064
+matplotlib/mpl-data/fonts/ttf/DejaVuSerif-Italic.ttf,sha256=PnmU-8VPoQzjNSpC1Uj63X2crbacsRCbydlg9trFfwQ,345612
+matplotlib/mpl-data/fonts/ttf/DejaVuSerif.ttf,sha256=EHJElW6ZYrnpb6zNxVGCXgrgiYrhNzcTPhuSGi_TX_o,379740
+matplotlib/mpl-data/fonts/ttf/DejaVuSerifDisplay.ttf,sha256=KRTzLkfHd8J75Wd6-ufbTeefnkXeb8kJfZlJwjwU99U,14300
+matplotlib/mpl-data/fonts/ttf/LICENSE_DEJAVU,sha256=11k43sCY8G8Kw8AIUwZdlPAgvhw8Yu8dwpdboVtNmw4,4816
+matplotlib/mpl-data/fonts/ttf/LICENSE_STIX,sha256=urPTHf7wf0g2JPL2XycR52BluOcnMnixwHHt4QQcmVk,5476
+matplotlib/mpl-data/fonts/ttf/STIXGeneral.ttf,sha256=FnN4Ax4t3cYhbWeBnJJg6aBv_ExHjk4jy5im_USxg8I,448228
+matplotlib/mpl-data/fonts/ttf/STIXGeneralBol.ttf,sha256=6FM9xwg_o0a9oZM9YOpKg7Z9CUW86vGzVB-CtKDixqA,237360
+matplotlib/mpl-data/fonts/ttf/STIXGeneralBolIta.ttf,sha256=mHiP1LpI37sr0CbA4gokeosGxzcoeWKLemuw1bsJc2w,181152
+matplotlib/mpl-data/fonts/ttf/STIXGeneralItalic.ttf,sha256=bPyzM9IrfDxiO9_UAXTxTIXD1nMcphZsHtyAFA6uhSc,175040
+matplotlib/mpl-data/fonts/ttf/STIXNonUni.ttf,sha256=Ulb34CEzWsSFTRgPDovxmJZOwvyCAXYnbhaqvGU3u1c,59108
+matplotlib/mpl-data/fonts/ttf/STIXNonUniBol.ttf,sha256=XRBqW3jR_8MBdFU0ObhiV7-kXwiBIMs7QVClHcT5tgs,30512
+matplotlib/mpl-data/fonts/ttf/STIXNonUniBolIta.ttf,sha256=pb22DnbDf2yQqizotc3wBDqFGC_g27YcCGJivH9-Le8,41272
+matplotlib/mpl-data/fonts/ttf/STIXNonUniIta.ttf,sha256=BMr9pWiBv2YIZdq04X4c3CgL6NPLUPrl64aV1N4w9Ug,46752
+matplotlib/mpl-data/fonts/ttf/STIXSizFiveSymReg.ttf,sha256=wYuH1gYUpCuusqItRH5kf9p_s6mUD-9X3L5RvRtKSxs,13656
+matplotlib/mpl-data/fonts/ttf/STIXSizFourSymBol.ttf,sha256=yNdvjUoSmsZCULmD7SVq9HabndG9P4dPhboL1JpAf0s,12228
+matplotlib/mpl-data/fonts/ttf/STIXSizFourSymReg.ttf,sha256=-9xVMYL4_1rcO8FiCKrCfR4PaSmKtA42ddLGqwtei1w,15972
+matplotlib/mpl-data/fonts/ttf/STIXSizOneSymBol.ttf,sha256=cYexyo8rZcdqMlpa9fNF5a2IoXLUTZuIvh0JD1Qp0i4,12556
+matplotlib/mpl-data/fonts/ttf/STIXSizOneSymReg.ttf,sha256=0lbHzpndzJmO8S42mlkhsz5NbvJLQCaH5Mcc7QZRDzc,19760
+matplotlib/mpl-data/fonts/ttf/STIXSizThreeSymBol.ttf,sha256=3eBc-VtYbhQU3BnxiypfO6eAzEu8BdDvtIJSFbkS2oY,12192
+matplotlib/mpl-data/fonts/ttf/STIXSizThreeSymReg.ttf,sha256=XFSKCptbESM8uxHtUFSAV2cybwxhSjd8dWVByq6f3w0,15836
+matplotlib/mpl-data/fonts/ttf/STIXSizTwoSymBol.ttf,sha256=MUCYHrA0ZqFiSE_PjIGlJZgMuv79aUgQqE7Dtu3kuo0,12116
+matplotlib/mpl-data/fonts/ttf/STIXSizTwoSymReg.ttf,sha256=_sdxDuEwBDtADpu9CyIXQxV7sIqA2TZVBCUiUjq5UCk,15704
+matplotlib/mpl-data/fonts/ttf/cmb10.ttf,sha256=B0SXtQxD6ldZcYFZH5iT04_BKofpUQT1ZX_CSB9hojo,25680
+matplotlib/mpl-data/fonts/ttf/cmex10.ttf,sha256=ryjwwXByOsd2pxv6WVrKCemNFa5cPVTOGa_VYZyWqQU,21092
+matplotlib/mpl-data/fonts/ttf/cmmi10.ttf,sha256=MJKWW4gR_WpnZXmWZIRRgfwd0TMLk3-RWAjEhdMWI00,32560
+matplotlib/mpl-data/fonts/ttf/cmr10.ttf,sha256=Tdl2GwWMAJ25shRfVe5mF9CTwnPdPWxbPkP_YRD6m_Y,26348
+matplotlib/mpl-data/fonts/ttf/cmss10.ttf,sha256=ffkag9BbLkcexjjLC0NaNgo8eSsJ_EKn2mfpHy55EVo,20376
+matplotlib/mpl-data/fonts/ttf/cmsy10.ttf,sha256=uyJu2TLz8QDNDlL15JEu5VO0G2nnv9uNOFTbDrZgUjI,29396
+matplotlib/mpl-data/fonts/ttf/cmtt10.ttf,sha256=YhHwmuk1mZka_alwwkZp2tGnfiU9kVYk-_IS9wLwcdc,28136
+matplotlib/mpl-data/images/back-symbolic.svg,sha256=Okj_ressZkfe6Ewv_o7GF5toc5qWCeFkQ2cHQ25BdVE,1532
+matplotlib/mpl-data/images/back.pdf,sha256=ZR7CJo_dAeCM-KlaGvskgtHQyRtrPIolc8REOmcoqJk,1623
+matplotlib/mpl-data/images/back.png,sha256=E4dGf4Gnz1xJ1v2tMygHV0YNQgShreDeVApaMb-74mU,380
+matplotlib/mpl-data/images/back.svg,sha256=Okj_ressZkfe6Ewv_o7GF5toc5qWCeFkQ2cHQ25BdVE,1532
+matplotlib/mpl-data/images/back_large.png,sha256=9A6hUSQeszhYONE4ZuH3kvOItM0JfDVu6tkfromCbsQ,620
+matplotlib/mpl-data/images/filesave-symbolic.svg,sha256=dMGXvLSOHPu44kiWgZx-B_My_tLWaP6J6GgxJfL4FW0,2049
+matplotlib/mpl-data/images/filesave.pdf,sha256=P1EPPV2g50WTt8UaX-6kFoTZM1xVqo6S2H6FJ6Zd1ec,1734
+matplotlib/mpl-data/images/filesave.png,sha256=b7ctucrM_F2mG-DycTedG_a_y4pHkx3F-zM7l18GLhk,458
+matplotlib/mpl-data/images/filesave.svg,sha256=dMGXvLSOHPu44kiWgZx-B_My_tLWaP6J6GgxJfL4FW0,2049
+matplotlib/mpl-data/images/filesave_large.png,sha256=LNbRD5KZ3Kf7nbp-stx_a1_6XfGBSWUfDdpgmnzoRvk,720
+matplotlib/mpl-data/images/forward-symbolic.svg,sha256=kOiKq3a4mieMRLVCwQBdOMTRrWG2NOX_5-rbAFHpdmQ,1551
+matplotlib/mpl-data/images/forward.pdf,sha256=KIqIL4YId43LkcOxV_TT5uvz1SP8k5iUNUeJmAElMV8,1630
+matplotlib/mpl-data/images/forward.png,sha256=pKbLepgGiGeyY2TCBl8svjvm7Z4CS3iysFxcq4GR-wk,357
+matplotlib/mpl-data/images/forward.svg,sha256=kOiKq3a4mieMRLVCwQBdOMTRrWG2NOX_5-rbAFHpdmQ,1551
+matplotlib/mpl-data/images/forward_large.png,sha256=36h7m7DZDHql6kkdpNPckyi2LKCe_xhhyavWARz_2kQ,593
+matplotlib/mpl-data/images/hand.pdf,sha256=hspwkNY915KPD7AMWnVQs7LFPOtlcj0VUiLu76dMabQ,4172
+matplotlib/mpl-data/images/hand.png,sha256=2cchRETGKa0hYNKUxnJABwkyYXEBPqJy_VqSPlT0W2Q,979
+matplotlib/mpl-data/images/hand.svg,sha256=hxxBtakaVFA7mpZOGakvo0QUcb2x06rojeS5gnVmyuc,4906
+matplotlib/mpl-data/images/help-symbolic.svg,sha256=XVcFcuzcL3SQ3LjfSbtdLYDjoB5YUkj2jk2Gk8vaZF8,1890
+matplotlib/mpl-data/images/help.pdf,sha256=CeE978IMi0YWznWKjIT1R8IrP4KhZ0S7usPUvreSgcA,1813
+matplotlib/mpl-data/images/help.png,sha256=s4pQrqaQ0py8I7vc9hv3BI3DO_tky-7YBMpaHuBDCBY,472
+matplotlib/mpl-data/images/help.svg,sha256=XVcFcuzcL3SQ3LjfSbtdLYDjoB5YUkj2jk2Gk8vaZF8,1890
+matplotlib/mpl-data/images/help_large.png,sha256=1IwEyWfGRgnoCWM-r9CJHEogTJVD5n1c8LXTK4AJ4RE,747
+matplotlib/mpl-data/images/home-symbolic.svg,sha256=ptrus8h5PZTi9ahYfnaz-uZ8MAHCr72aPeMW48TBR9Q,1911
+matplotlib/mpl-data/images/home.pdf,sha256=e0e0pI-XRtPmvUCW2VTKL1DeYu1pvPmUUeRSgEbWmik,1737
+matplotlib/mpl-data/images/home.png,sha256=IcFdAAUa6_A0qt8IO3I8p4rpXpQgAlJ8ndBECCh7C1w,468
+matplotlib/mpl-data/images/home.svg,sha256=ptrus8h5PZTi9ahYfnaz-uZ8MAHCr72aPeMW48TBR9Q,1911
+matplotlib/mpl-data/images/home_large.png,sha256=uxS2O3tWOHh1iau7CaVV4ermIJaZ007ibm5Z3i8kXYg,790
+matplotlib/mpl-data/images/matplotlib.pdf,sha256=BkSUf-2xoij-eXfpV2t7y1JFKG1zD1gtV6aAg3Xi_wE,22852
+matplotlib/mpl-data/images/matplotlib.png,sha256=w8KLRYVa-voUZXa41hgJauQuoois23f3NFfdc72pUYY,1283
+matplotlib/mpl-data/images/matplotlib.svg,sha256=QiTIcqlQwGaVPtHsEk-vtmJk1wxwZSvijhqBe_b9VCI,62087
+matplotlib/mpl-data/images/matplotlib_large.png,sha256=ElRoue9grUqkZXJngk-nvh4GKfpvJ4gE69WryjCbX5U,3088
+matplotlib/mpl-data/images/move-symbolic.svg,sha256=_uamLnjQ20iwSuKbd8JvTXUFaRq4206MrpFWvtErr8I,2529
+matplotlib/mpl-data/images/move.pdf,sha256=CXk3PGK9WL5t-5J-G2X5Tl-nb6lcErTBS5oUj2St6aU,1867
+matplotlib/mpl-data/images/move.png,sha256=TmjR41IzSzxGbhiUcV64X0zx2BjrxbWH3cSKvnG2vzc,481
+matplotlib/mpl-data/images/move.svg,sha256=_uamLnjQ20iwSuKbd8JvTXUFaRq4206MrpFWvtErr8I,2529
+matplotlib/mpl-data/images/move_large.png,sha256=Skjz2nW_RTA5s_0g88gdq2hrVbm6DOcfYW4Fu42Fn9U,767
+matplotlib/mpl-data/images/qt4_editor_options.pdf,sha256=2qu6GVyBrJvVHxychQoJUiXPYxBylbH2j90QnytXs_w,1568
+matplotlib/mpl-data/images/qt4_editor_options.png,sha256=EryQjQ5hh2dwmIxtzCFiMN1U6Tnd11p1CDfgH5ZHjNM,380
+matplotlib/mpl-data/images/qt4_editor_options.svg,sha256=sdrNIxYT-BLvJ30ASnaRQ5PxF3SB41-pgdaIJT0KqBg,1264
+matplotlib/mpl-data/images/qt4_editor_options_large.png,sha256=-Pd-9Vh5aIr3PZa8O6Ge_BLo41kiEnpmkdDj8a11JkY,619
+matplotlib/mpl-data/images/subplots-symbolic.svg,sha256=Gq4fDSS99Rv5rbR8_nenV6jcY5VsKPARWeH-BZBk9CU,2150
+matplotlib/mpl-data/images/subplots.pdf,sha256=Q0syPMI5EvtgM-CE-YXKOkL9eFUAZnj_X2Ihoj6R4p4,1714
+matplotlib/mpl-data/images/subplots.png,sha256=MUfCItq3_yzb9yRieGOglpn0Y74h8IA7m5i70B63iRc,445
+matplotlib/mpl-data/images/subplots.svg,sha256=Gq4fDSS99Rv5rbR8_nenV6jcY5VsKPARWeH-BZBk9CU,2150
+matplotlib/mpl-data/images/subplots_large.png,sha256=Edu9SwVMQEXJZ5ogU5cyW7VLcwXJdhdf-EtxxmxdkIs,662
+matplotlib/mpl-data/images/zoom_to_rect-symbolic.svg,sha256=uMmdGkO43ZHlezkpieR3_MiqlEc5vROffRDOhY4sxm4,1499
+matplotlib/mpl-data/images/zoom_to_rect.pdf,sha256=SEvPc24gfZRpl-dHv7nx8KkxPyU66Kq4zgQTvGFm9KA,1609
+matplotlib/mpl-data/images/zoom_to_rect.png,sha256=aNz3QZBrIgxu9E-fFfaQweCVNitGuDUFoC27e5NU2L4,530
+matplotlib/mpl-data/images/zoom_to_rect.svg,sha256=uMmdGkO43ZHlezkpieR3_MiqlEc5vROffRDOhY4sxm4,1499
+matplotlib/mpl-data/images/zoom_to_rect_large.png,sha256=V6pkxmm6VwFExdg_PEJWdK37HB7k3cE_corLa7RbUMk,1016
+matplotlib/mpl-data/kpsewhich.lua,sha256=RdyYaBnBLy3NsB5c2R5FGrKu-V-WBcZim24NWilsTfw,139
+matplotlib/mpl-data/matplotlibrc,sha256=wlUqhpUjmDxJ3C9QmmYZiUyDuRGo9lWyNGidWJKogFM,42364
+matplotlib/mpl-data/plot_directive/plot_directive.css,sha256=utSJ1oETz0UG6AC9hU134J_JY78ENijqMZXN0JMBUfk,318
+matplotlib/mpl-data/sample_data/Minduka_Present_Blue_Pack.png,sha256=XnKGiCanpDKalQ5anvo5NZSAeDP7fyflzQAaivuc0IE,13634
+matplotlib/mpl-data/sample_data/README.txt,sha256=ABz19VBKfGewdY39QInG9Qccgn1MTYV3bT5Ph7TCy2Y,128
+matplotlib/mpl-data/sample_data/Stocks.csv,sha256=72878aZNXGxd5wLvFUw_rnj-nfg4gqtrucZji-w830c,67924
+matplotlib/mpl-data/sample_data/axes_grid/bivariate_normal.npy,sha256=DpWZ9udAh6ospYqneEa27D6EkRgORFwHosacZXVu98U,1880
+matplotlib/mpl-data/sample_data/data_x_x2_x3.csv,sha256=A0SU3buOUGhT-NI_6LQ6p70fFSIU3iLFdgzvzrKR6SE,132
+matplotlib/mpl-data/sample_data/eeg.dat,sha256=KGVjFt8ABKz7p6XZirNfcxSTOpGGNuyA8JYErRKLRBc,25600
+matplotlib/mpl-data/sample_data/embedding_in_wx3.xrc,sha256=cUqVw5vDHNSZoaO4J0ebZUf5SrJP36775abs7R9Bclg,2186
+matplotlib/mpl-data/sample_data/goog.npz,sha256=QAkXzzDmtmT3sNqT18dFhg06qQCNqLfxYNLdEuajGLE,22845
+matplotlib/mpl-data/sample_data/grace_hopper.jpg,sha256=qMptc0dlcDsJcoq0f-WfRz2Trjln_CTHwCiMPHrbcTA,61306
+matplotlib/mpl-data/sample_data/jacksboro_fault_dem.npz,sha256=1JP1CjPoKkQgSUxU0fyhU50Xe9wnqxkLxf5ukvYvtjc,174061
+matplotlib/mpl-data/sample_data/logo2.png,sha256=DXNx4FXeyqxHy26AmvNELpwezQLxweLQY9HP7ktKIdc,22279
+matplotlib/mpl-data/sample_data/membrane.dat,sha256=q3lbQpIBpbtXXGNw1eFwkN_PwxdDGqk4L46IE2b0M1c,48000
+matplotlib/mpl-data/sample_data/msft.csv,sha256=GArKb0O3DgKZRsKdJf6lX3rMSf-PCekIiBoLNdgF7Mk,3211
+matplotlib/mpl-data/sample_data/s1045.ima.gz,sha256=MrQk1k9it-ccsk0p_VOTitVmTWCAVaZ6srKvQ2n4uJ4,33229
+matplotlib/mpl-data/sample_data/topobathy.npz,sha256=AkTgMpFwLfRQJNy1ysvE89TLMNct-n_TccSsYcQrT78,45224
+matplotlib/mpl-data/stylelib/Solarize_Light2.mplstyle,sha256=aytOm4eT_SPvs7HC28ZY4GukeN44q-SE0JEMCR8kVOk,1257
+matplotlib/mpl-data/stylelib/_classic_test_patch.mplstyle,sha256=iopHpMaM3im_AK2aiHGuM2DKM5i9Kc84v6NQEoSb10Q,167
+matplotlib/mpl-data/stylelib/_mpl-gallery-nogrid.mplstyle,sha256=1VOL3USqD6iuGQaSynNg1QhyUwvKLnkLyUKdbBMnnqg,489
+matplotlib/mpl-data/stylelib/_mpl-gallery.mplstyle,sha256=MN-q59CiDqHXB8xFKXxzCbJJbJmNDhBe9lDJJAoMTPA,504
+matplotlib/mpl-data/stylelib/bmh.mplstyle,sha256=-KbhaI859BITHIoyUZIfpQDjfckgLAlDAS_ydKsm6mc,712
+matplotlib/mpl-data/stylelib/classic.mplstyle,sha256=tGkwXsHm15yZij7HT_9N8L9_z8-D_ao2wUWtimVikGA,24693
+matplotlib/mpl-data/stylelib/dark_background.mplstyle,sha256=Ht6phZUy3zNRdcfHKcSb1uh3O8DunSPX8HPt9xTyzuo,658
+matplotlib/mpl-data/stylelib/fast.mplstyle,sha256=yTa2YEIIP9xi5V_G0p2vSlxghuhNwjRi9gPECMxyRiM,288
+matplotlib/mpl-data/stylelib/fivethirtyeight.mplstyle,sha256=WNUmAFuBPcqQPVgt6AS1ldy8Be2XO01N-1YQL__Q6ZY,832
+matplotlib/mpl-data/stylelib/ggplot.mplstyle,sha256=u2oPHMLWFtZcpIjHk2swi2Nrt4NgnEtof5lxcwM0RD0,956
+matplotlib/mpl-data/stylelib/grayscale.mplstyle,sha256=KCLg-pXpns9cnKDXKN2WH6mV41OH-6cbT-5zKQotSdw,526
+matplotlib/mpl-data/stylelib/seaborn-v0_8-bright.mplstyle,sha256=pDqn3-NUyVLvlfkYs8n8HzNZvmslVMChkeH-HtZuJIc,144
+matplotlib/mpl-data/stylelib/seaborn-v0_8-colorblind.mplstyle,sha256=eCSzFj5_2vR6n5qu1rHE46wvSVGZcdVqz85ov40ZsH8,148
+matplotlib/mpl-data/stylelib/seaborn-v0_8-dark-palette.mplstyle,sha256=p5ABKNQHRG7bk4HXqMQrRBjDlxGAo3RCXHdQmP7g-Ng,142
+matplotlib/mpl-data/stylelib/seaborn-v0_8-dark.mplstyle,sha256=I4xQ75vE5_9X4k0cNDiqhhnF3OcrZ2xlPX8Ll7OCkoE,667
+matplotlib/mpl-data/stylelib/seaborn-v0_8-darkgrid.mplstyle,sha256=2bXOSzS5gmPzRBrRmzVWyhg_7ZaBRQ6t_-O-cRuyZoA,670
+matplotlib/mpl-data/stylelib/seaborn-v0_8-deep.mplstyle,sha256=44dLcXjjRgR-6yaopgGRInaVgz3jk8VJVQTbBIcxRB0,142
+matplotlib/mpl-data/stylelib/seaborn-v0_8-muted.mplstyle,sha256=T4o3jvqKD_ImXDkp66XFOV_xrBVFUolJU34JDFk1Xkk,143
+matplotlib/mpl-data/stylelib/seaborn-v0_8-notebook.mplstyle,sha256=PcvZQbYrDdducrNlavBPmQ1g2minio_9GkUUFRdgtoM,382
+matplotlib/mpl-data/stylelib/seaborn-v0_8-paper.mplstyle,sha256=n0mboUp2C4Usq2j6tNWcu4TZ_YT4-kKgrYO0t-rz1yw,393
+matplotlib/mpl-data/stylelib/seaborn-v0_8-pastel.mplstyle,sha256=8nV8qRpbUrnFZeyE6VcQ1oRuZPLil2W74M2U37DNMOE,144
+matplotlib/mpl-data/stylelib/seaborn-v0_8-poster.mplstyle,sha256=dUaKqTE4MRfUq2rWVXbbou7kzD7Z9PE9Ko8aXLza8JA,403
+matplotlib/mpl-data/stylelib/seaborn-v0_8-talk.mplstyle,sha256=7FnBaBEdWBbncTm6_ER-EQVa_bZgU7dncgez-ez8R74,403
+matplotlib/mpl-data/stylelib/seaborn-v0_8-ticks.mplstyle,sha256=CITZmZFUFp40MK2Oz8tI8a7WRoCizQU9Z4J172YWfWw,665
+matplotlib/mpl-data/stylelib/seaborn-v0_8-white.mplstyle,sha256=WjJ6LEU6rlCwUugToawciAbKP9oERFHr9rfFlUrdTx0,665
+matplotlib/mpl-data/stylelib/seaborn-v0_8-whitegrid.mplstyle,sha256=ec4BjsNzmOvHptcJ3mdPxULF3S1_U1EUocuqfIpw-Nk,664
+matplotlib/mpl-data/stylelib/seaborn-v0_8.mplstyle,sha256=_Xu6qXKzi4b3GymCOB1b1-ykKTQ8xhDliZ8ezHGTiAs,1130
+matplotlib/mpl-data/stylelib/tableau-colorblind10.mplstyle,sha256=BsirZVd1LmPWT4tBIz6loZPjZcInoQrIGfC7rvzqmJw,190
+matplotlib/offsetbox.py,sha256=OyAGOJ7LPT1X5CAyZwuIS1W3l-OKPWzpSF1UxCF3voU,53178
+matplotlib/offsetbox.pyi,sha256=qtRlo1OQQ1eUSRwzvHT8EWa8a2YQ54b9j1YZwxpo0AQ,10390
+matplotlib/patches.py,sha256=sfawmLPt_cpMZ-URNub4_COlgJFrxRFA5goJhg3_HcE,162832
+matplotlib/patches.pyi,sha256=OvxnwlppjOnWDTAu17y4qIYnk8G2lEVh19SrsJweW8U,22543
+matplotlib/path.py,sha256=N87A45qgGW337KOriFkNSqjGhC7ZT0B9I5MDBbB2ebo,42079
+matplotlib/path.pyi,sha256=N1XOCWSUG4RtCcMo02yvvq3HDYo_369oKQkEJUHN80c,4777
+matplotlib/patheffects.py,sha256=s7J8EiS3i110JYSgQdoH16xaNHMf9xnUhj9SkJjwSmQ,18789
+matplotlib/patheffects.pyi,sha256=7-FhuxGGrer94GtJ1sZ0YxOmK6Nv4oixTmsKb6-ijOg,3664
+matplotlib/projections/__init__.py,sha256=jq1SJYHwkgHKHA-c_4r9j-dV2ZpgmUkWZnCOVNPtmKo,4436
+matplotlib/projections/__init__.pyi,sha256=D28dSYmwZcSBFBtNDer-QqE_lqXAhHKersuAlvi89jE,673
+matplotlib/projections/__pycache__/__init__.cpython-310.pyc,,
+matplotlib/projections/__pycache__/geo.cpython-310.pyc,,
+matplotlib/projections/__pycache__/polar.cpython-310.pyc,,
+matplotlib/projections/geo.py,sha256=inOLKvVTfZUTC-1Wl0Rq9eXouplbcVbWptkRVsFTkj8,17711
+matplotlib/projections/geo.pyi,sha256=vPfhvj7_e0ZnKjyfDUNC89RGCktycJBPnn5D8w0A7N8,3775
+matplotlib/projections/polar.py,sha256=d448pT7GPT0ukQTsr97NkPNtjQwC4ypDUJsPePEuj3w,56568
+matplotlib/projections/polar.pyi,sha256=IWNSLQIo5cXFBJur5VFVDQBwAtq5n1XFZMnrj85mCBg,6636
+matplotlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+matplotlib/pylab.py,sha256=VqUqd2J2-dKtltZtsYP8ePKoX1jsNDpTyqlcmpfC-lo,2369
+matplotlib/pyplot.py,sha256=ydE449Dwz5FMgmx18EC7O_PnNJvDZJPxExAsK8BR_vs,147190
+matplotlib/quiver.py,sha256=YDCU2XRe2VQhXo-LdAsM6Aa5doSIOikWfgLFYT-i4no,46177
+matplotlib/quiver.pyi,sha256=7WC5M42icWeWVzOvDJVNdZ3NC4KvZz1M38hXeNRd1dE,5581
+matplotlib/rcsetup.py,sha256=St4wrlo-NAy8iIZxTNl4cQSyJB6ejeW6QYi7P1K-BFM,51836
+matplotlib/rcsetup.pyi,sha256=0VTIhzfKgBcKxOeOdoKq1oa7ZubalOj9Ks0efE0-cms,4337
+matplotlib/sankey.py,sha256=qFEkTvL15SL0_vIOLldCyb5YsYniUzFnXs09kDuNmI0,36158
+matplotlib/sankey.pyi,sha256=xa6EMuSEZQYycZWdqlxIgWqQ7gfWKPKF9ZDK7WYQAC0,1462
+matplotlib/scale.py,sha256=GZKWo9toXXvkbxS28D7pMU2Fms-F4eR2RUCIjesKk1Q,25990
+matplotlib/scale.pyi,sha256=-ptRptcqiAuzfKwrjgSWWOxFmjRUTOKGwIoWtuBXKgY,5057
+matplotlib/sphinxext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+matplotlib/sphinxext/__pycache__/__init__.cpython-310.pyc,,
+matplotlib/sphinxext/__pycache__/figmpl_directive.cpython-310.pyc,,
+matplotlib/sphinxext/__pycache__/mathmpl.cpython-310.pyc,,
+matplotlib/sphinxext/__pycache__/plot_directive.cpython-310.pyc,,
+matplotlib/sphinxext/__pycache__/roles.cpython-310.pyc,,
+matplotlib/sphinxext/figmpl_directive.py,sha256=GaIho4pRZ9f0vKx9g6BSj64AF2BdRWV6Z_uzamCytWs,9118
+matplotlib/sphinxext/mathmpl.py,sha256=R24VAgKSOkYx2sarr2MGHgsosvKopih6JEIu8VM65wc,7810
+matplotlib/sphinxext/plot_directive.py,sha256=6eoNy8lyELEpjYgUvrAkjEqDOc4-5ndQ-zjpF4gKQ74,32430
+matplotlib/sphinxext/roles.py,sha256=U7P4t06foLF2PsZJrTN4mfaspKGRoYwFZ3ijIhIUVyo,4882
+matplotlib/spines.py,sha256=TM77Hz0LzJtp-12RTiykKNenIp_vwzrvkGooxMK6Upc,21593
+matplotlib/spines.pyi,sha256=QXWS95dKxHbwzrtky-lrd4bXuj7eiz8mv54qIrMd0Ks,2956
+matplotlib/stackplot.py,sha256=G4sylNIsZpJkWvbc4bdYdlyidicZFFB7e5J2jOtYUwU,4968
+matplotlib/stackplot.pyi,sha256=311zv4wPimk9_GJdr_sfu1laNZRpKwsZ8pLMq16v8UQ,536
+matplotlib/streamplot.py,sha256=rXVKYEi4MfSg3HnAaWb8w4qFp95mRf6dosMVqtXZEpE,24011
+matplotlib/streamplot.pyi,sha256=wA0K5e_ZjXneS5WzonHxoKPLla3-IdflAcIrB0svtOY,2664
+matplotlib/style/__init__.py,sha256=fraQtyBC3TY2ZTsLdxL7zNs9tJYZtje7tbiqEf3M56M,140
+matplotlib/style/__pycache__/__init__.cpython-310.pyc,,
+matplotlib/style/__pycache__/core.cpython-310.pyc,,
+matplotlib/style/core.py,sha256=P67uPZwbLqggEHTpKTc17G20QeUl00P7AFSONf77L2g,8609
+matplotlib/style/core.pyi,sha256=DElPp0fbkwKaaVOVb5VGHfI8ohRB9m4uVGKjZl3A65E,449
+matplotlib/table.py,sha256=Q76nxe9lf-izvLsSE21PMyRImRWUehA3U-SfQnwj8x0,27161
+matplotlib/table.pyi,sha256=AMQswiPK8WZ8NATDqy5GtwAlvwR5qStRFDYL13gxRYg,3041
+matplotlib/testing/__init__.py,sha256=pTaqH1qgGNBeWCmvK_vjqFJXJ9dvZXCaKQ-8jHSpaEc,6942
+matplotlib/testing/__init__.pyi,sha256=ffqfetWzyCVrSx7BlnoxCmbgIaZg2x57nDrq9eucRk0,1752
+matplotlib/testing/__pycache__/__init__.cpython-310.pyc,,
+matplotlib/testing/__pycache__/_markers.cpython-310.pyc,,
+matplotlib/testing/__pycache__/compare.cpython-310.pyc,,
+matplotlib/testing/__pycache__/conftest.cpython-310.pyc,,
+matplotlib/testing/__pycache__/decorators.cpython-310.pyc,,
+matplotlib/testing/__pycache__/exceptions.cpython-310.pyc,,
+matplotlib/testing/__pycache__/widgets.cpython-310.pyc,,
+matplotlib/testing/_markers.py,sha256=0iNyOi25XLv_gTfSUqiRizdSqJzozePPBMRo72H2Je4,1419
+matplotlib/testing/compare.py,sha256=d4lEAmi-C0rCxLrELwfiQezOthqEgnhvuKeIskYim0Q,19332
+matplotlib/testing/compare.pyi,sha256=xlJ4chgXKe567NUavlu-dalyPr4wAQUbd2Fz6aK_JII,1192
+matplotlib/testing/conftest.py,sha256=-boEzYRlszzHJ2T9ZJq5qu8B38BlJ2hNpkzpIRGCSsA,3669
+matplotlib/testing/conftest.pyi,sha256=4_MStQN6gy_h0YfhlPbqR81QVeVcn-FRqaKyyXedUEk,332
+matplotlib/testing/decorators.py,sha256=viNGSCIQ9Ul_wjMCjrm-ebC_BClwU1Zkhxww6dq1m2k,18021
+matplotlib/testing/decorators.pyi,sha256=0fSpdLBtEH7ZP_trVJ7RPxNtOX9sJ_z-MkNsbUxF8nM,872
+matplotlib/testing/exceptions.py,sha256=72QmjiHG7DwxSvlJf8mei-hRit5AH3NKh0-osBo4YbY,138
+matplotlib/testing/jpl_units/Duration.py,sha256=9FMBu9uj6orCWtf23cf6_9HCFUC50xAHrCzaxATwQfM,3966
+matplotlib/testing/jpl_units/Epoch.py,sha256=-FGxeq-VvCS9GVPwOEE5ind_G4Tl9ztD-gYcW9CWzjo,6100
+matplotlib/testing/jpl_units/EpochConverter.py,sha256=fhWjyP567bzcTU_oNuJJpucoolqS88Nt-yEFg1-3yEk,2944
+matplotlib/testing/jpl_units/StrConverter.py,sha256=codGw9b_Zc-MG_YK4CiyMrnMR8ahR9hw836O2SsV8QI,2865
+matplotlib/testing/jpl_units/UnitDbl.py,sha256=EABjyEK4MVouyvlwi_9KdYDg-qbYY3aLHoUjRw37Fb0,5882
+matplotlib/testing/jpl_units/UnitDblConverter.py,sha256=B8DssrQVyC4mwvSFP78cGL0vCnZgVhDaAbZE-jsXLUg,2828
+matplotlib/testing/jpl_units/UnitDblFormatter.py,sha256=246hgA4_pCfJm-P94hEsxqnTS9t0XlvLC8p1v_bw2pU,657
+matplotlib/testing/jpl_units/__init__.py,sha256=p__9RUwrt2LJ2eoT2JPM-42XLxSJrfA4az3rN5uP6d4,2684
+matplotlib/testing/jpl_units/__pycache__/Duration.cpython-310.pyc,,
+matplotlib/testing/jpl_units/__pycache__/Epoch.cpython-310.pyc,,
+matplotlib/testing/jpl_units/__pycache__/EpochConverter.cpython-310.pyc,,
+matplotlib/testing/jpl_units/__pycache__/StrConverter.cpython-310.pyc,,
+matplotlib/testing/jpl_units/__pycache__/UnitDbl.cpython-310.pyc,,
+matplotlib/testing/jpl_units/__pycache__/UnitDblConverter.cpython-310.pyc,,
+matplotlib/testing/jpl_units/__pycache__/UnitDblFormatter.cpython-310.pyc,,
+matplotlib/testing/jpl_units/__pycache__/__init__.cpython-310.pyc,,
+matplotlib/testing/widgets.py,sha256=d5wWO4ulIBFj0ecOiuxqTTDInuYI6-1MSQp0SX9HG7c,3471
+matplotlib/testing/widgets.pyi,sha256=Ioau7Q2aPRDZLx8hze2DOe3E1vn7QPxePC74WMR7tFc,831
+matplotlib/tests/__init__.py,sha256=XyXveEAxafB87gnbx0jkC0MggzKO8FvORq_6RtJRwo4,366
+matplotlib/tests/__pycache__/__init__.cpython-310.pyc,,
+matplotlib/tests/__pycache__/conftest.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_afm.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_agg.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_agg_filter.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_animation.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_api.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_arrow_patches.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_artist.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_axes.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_axis.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_bases.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_cairo.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_gtk3.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_macosx.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_nbagg.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_pdf.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_pgf.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_ps.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_qt.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_svg.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_template.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_tk.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_tools.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backend_webagg.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_backends_interactive.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_basic.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_bbox_tight.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_category.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_cbook.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_collections.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_colorbar.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_colors.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_compare_images.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_constrainedlayout.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_container.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_contour.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_cycles.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_dates.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_datetime.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_determinism.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_doc.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_dviread.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_figure.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_font_manager.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_fontconfig_pattern.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_ft2font.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_getattr.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_gridspec.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_image.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_legend.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_lines.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_marker.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_mathtext.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_matplotlib.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_mlab.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_offsetbox.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_patches.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_path.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_patheffects.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_pickle.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_png.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_polar.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_preprocess_data.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_pyplot.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_quiver.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_rcparams.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_sankey.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_scale.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_simplification.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_skew.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_sphinxext.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_spines.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_streamplot.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_style.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_subplots.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_table.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_testing.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_texmanager.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_text.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_textpath.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_ticker.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_tightlayout.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_transforms.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_triangulation.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_ttconv.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_type1font.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_units.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_usetex.cpython-310.pyc,,
+matplotlib/tests/__pycache__/test_widgets.cpython-310.pyc,,
+matplotlib/tests/conftest.py,sha256=HNR8xF4YiUoKY03WKoeABGwSRcKFMwI9cNFXZJDzz-A,119
+matplotlib/tests/test_afm.py,sha256=A7jm2o-QaQH9SSpiFxGtZkbVU0LJZE69jfPv7RczOD4,3701
+matplotlib/tests/test_agg.py,sha256=BwRu6BuTWPZYsc2YxcfllV9cvZ7WPbCe36Alhmkr-6k,10740
+matplotlib/tests/test_agg_filter.py,sha256=3c_Smtb4OHEOfdMFCOb2qKhzMXSbNoaUtsJ0pW47Q44,1067
+matplotlib/tests/test_animation.py,sha256=gwxe9pC1Jv00TjusWvgYiX32E1xMxGejSRkwqAoxuPY,17743
+matplotlib/tests/test_api.py,sha256=fTw5hpYH_N_2YeoYcKJwLwFwn4LXDAOy-ZgvyWwU6x4,3503
+matplotlib/tests/test_arrow_patches.py,sha256=wzczYyoF_YWuj5DjbNJ7iyAfWSkMXPYB1AjIoEEqoCM,6571
+matplotlib/tests/test_artist.py,sha256=9ZQ82ZP4PKIuzucDD45phJZBDnPJkdbcPeHzrGNhHF8,17433
+matplotlib/tests/test_axes.py,sha256=bipNAFvOLTz7gDKfhSBlFNh7A_nB35TvSQODjzdxawU,306431
+matplotlib/tests/test_axis.py,sha256=ecaZ66ng6NkwrffxyEug9GzEx4YouY49xamqyvrJ0kA,268
+matplotlib/tests/test_backend_bases.py,sha256=CDYfkBSD9xji68S6ytx5pSg1QwF3RGLOv5WSZW6lS1Q,22631
+matplotlib/tests/test_backend_cairo.py,sha256=O2LTYjsfPn__bKtTz4MGGBodpSshoPkzu0INsc18xmI,1821
+matplotlib/tests/test_backend_gtk3.py,sha256=6i9wimlBue9Tb-i_UyjMt_MdP9Z-SoOCXy5Tz64hK3Q,1739
+matplotlib/tests/test_backend_macosx.py,sha256=IgWMoxDqDP9du5w8iRrDygHgiuCQi4EgEsPXpVw3DWA,1723
+matplotlib/tests/test_backend_nbagg.py,sha256=o6ON7tt_LOW7wzg4StIMYuTgMFSPNWt1FOv2FFMIefk,1459
+matplotlib/tests/test_backend_pdf.py,sha256=G9ppQYISSVHpyEHShmzP-ItYc4W8wq2KnyZ8LWh9JYE,15145
+matplotlib/tests/test_backend_pgf.py,sha256=ai6Pr61a4_Dx826wo_vJGXYxI1N7ZtzBbx0TIMnwHog,13230
+matplotlib/tests/test_backend_ps.py,sha256=SxQYqNKDFNOhtifKw02qx95LeHFOcCiHZIbaNGsEMH8,12572
+matplotlib/tests/test_backend_qt.py,sha256=A1LntIOeismjmqels6bKt9LOiT9Z4lS-pxo1MG0Rw2I,12350
+matplotlib/tests/test_backend_svg.py,sha256=zChB85qffPQ9KmFQQ1OCZH0F3GhqVuZiu8Ac_MjXADw,21053
+matplotlib/tests/test_backend_template.py,sha256=uuE7oZ9pSBVDWrPL05B0WgCFsgv6HlXyetuPTfJn6a8,2184
+matplotlib/tests/test_backend_tk.py,sha256=kQ3R4TzI2fH-qs391q6zaD9pxMXgZ9zkxfS_hI_X5cI,8282
+matplotlib/tests/test_backend_tools.py,sha256=C-B7NCkyWsQ5KzQEnI5Be16DsAHHZJU9P5v9--wsF-o,501
+matplotlib/tests/test_backend_webagg.py,sha256=4Oc-z7w-mTGETB1x0FQ_gZP9qHfyWh5lwWc9qPkkisc,938
+matplotlib/tests/test_backends_interactive.py,sha256=1sT0tIjmlCOYOyOaAuBsCqMC-VlFbCoxyT0wausy6lw,28701
+matplotlib/tests/test_basic.py,sha256=8XmkUXa8LgZO-BXqo5AusB4beRBVBKl52kFdOrS_2Po,1133
+matplotlib/tests/test_bbox_tight.py,sha256=y08219QyXHk1KINciiFLiMIm4xVbCfhLe1Ch9rpV7jE,6313
+matplotlib/tests/test_category.py,sha256=S6Y681G-wU1R10GCdtDMmR6fbVGURSLzFOWu0SNkON8,11700
+matplotlib/tests/test_cbook.py,sha256=cnygK9Dotacl5IOHFCwVxkJ3wAZJ3RkZb3mNewSXyRg,31419
+matplotlib/tests/test_collections.py,sha256=dBXU5e_J582wAWrVoIUVaE3Jmu6H1z3umMcJejWk7Y4,46695
+matplotlib/tests/test_colorbar.py,sha256=EJKhhIA79JmAi2D9vAh3PK6Uujdvrm16usb4oGhPdqc,46648
+matplotlib/tests/test_colors.py,sha256=4MejF3jWuDTad8kL9NeIgvbT4-ysTF1MhL1f2Rwo070,60244
+matplotlib/tests/test_compare_images.py,sha256=NcBoT8HAxtzoR1zZBu0V3MFpGWtdFaDblQ8o3OTO6zM,3260
+matplotlib/tests/test_constrainedlayout.py,sha256=hQml8aHHoma6stcX0tUnWxeKbhHfma3ExJEoRY_zwc4,22737
+matplotlib/tests/test_container.py,sha256=FTewckOd3dJqLOzEUa29Itjqusk7Mx7MK5xPVMhzMmc,694
+matplotlib/tests/test_contour.py,sha256=29G1GzKbxSE8IZ2ewZOqFr0EbpuyczguA3rsYv4pztA,33252
+matplotlib/tests/test_cycles.py,sha256=3KyRmWH29WUgvIXUT06tKVDNCfDWqxuxlLueIp-FIl0,5996
+matplotlib/tests/test_dates.py,sha256=l9LbiYzmF-zlvwD2QdGBbWGgJNF94gRHhsYKLzIjI18,55944
+matplotlib/tests/test_datetime.py,sha256=_sh6R405rrZHce-WgH9GLcjLHXwTLpIPvVUs7BUQaCM,32621
+matplotlib/tests/test_determinism.py,sha256=gsz-JIDkSBev0Mm-bE1jxvsh1V1UJ_lRK-QCVeO-P_s,4626
+matplotlib/tests/test_doc.py,sha256=K6HhdRcHRUNNC0iIhxBLCq5tOqxqHBSvanHxXg5w5iI,1015
+matplotlib/tests/test_dviread.py,sha256=JeTuA2FMUj1FddxDVBXUtnvZYTgztE-CyRXL_mI20P0,2764
+matplotlib/tests/test_figure.py,sha256=9sUvk9A5VZQivMeiphTsrmm3g9eDuuiojtO-1-awSzE,58430
+matplotlib/tests/test_font_manager.py,sha256=tHeeojRH-zC2fIcSziFi-j_nzPDm3qbPdUl9CGOrNek,12222
+matplotlib/tests/test_fontconfig_pattern.py,sha256=LSR6lWF_0cVOshkGiflYaTCLcISRIJM6mjXm5QtDjX4,2168
+matplotlib/tests/test_ft2font.py,sha256=vvc6OOHPkVDwTaOQVP2kt9H1_scFZeOWBTb8zdSrVn8,4469
+matplotlib/tests/test_getattr.py,sha256=Tl_H1zpwLdSIVutc4vi-QwDCeWPzBGpN31N9ItzTkeQ,1090
+matplotlib/tests/test_gridspec.py,sha256=SYJuJucA_PyQ2Rsov1RaNhadOEWGDcMbQcVFrWIoy3I,1580
+matplotlib/tests/test_image.py,sha256=kU0we_NRlVWgZ6OjvrHbHbVsMcMZ1nTfbmtYqK3gorY,53038
+matplotlib/tests/test_legend.py,sha256=IodJOw0yGKQlHXxIpKaxwAEylLoqO9QiFy-4jHmI4UE,54842
+matplotlib/tests/test_lines.py,sha256=hqioyULLcVypE4oyCZoMzfMMXQbYRgKPYMmoKbQnRac,14791
+matplotlib/tests/test_marker.py,sha256=w0WVHoaD-6iybjUSENoVFFdUOOR13943JcE4sgz3qhI,11410
+matplotlib/tests/test_mathtext.py,sha256=SMzfo3HbfslCw7EmVYaWZgw975K0hMtjw6n0BQqn6pk,24513
+matplotlib/tests/test_matplotlib.py,sha256=YPBZQdO6BEC4mPKxXD_W-HoFzoOZwGGifYrYdCDcy48,2887
+matplotlib/tests/test_mlab.py,sha256=d4qMyogTFMrvlRZEpDs7SjhSmmCnBUMNgSX2bJU6eDk,42269
+matplotlib/tests/test_offsetbox.py,sha256=_QeANIzM3oAlyx8RB8KO6-y1v7nBsIHV0DDOrLjymMI,16119
+matplotlib/tests/test_patches.py,sha256=Da97JR1rG_Y__5iSMurf5S4XJlBJumR6CuWrKPDSjfU,31971
+matplotlib/tests/test_path.py,sha256=xJgfg1wQ0AZdTX3fFEh4Qy37Wozx7yY0pzfOqSml2V0,19247
+matplotlib/tests/test_patheffects.py,sha256=IqFuGi0wBB5ivyKAr2d4w_St48sbyuLVOSBmDK8FZWM,8089
+matplotlib/tests/test_pickle.py,sha256=etOZ-QcYF15jmUJpzRzbhBZ90qL9Mb3VOYCAnQ3RyWs,9607
+matplotlib/tests/test_png.py,sha256=xyXs9STg5WyoKCeqyK7zNoj5OGYlkJZIwP_GMIJqLTA,1240
+matplotlib/tests/test_polar.py,sha256=NPrQ1BCLfcaJJYRc6dK84kfTxyBsHaTjet9_JenewVs,15578
+matplotlib/tests/test_preprocess_data.py,sha256=cIVICUi1iahMQS30sqI5IlT2RYJRH2gJ0z60FyuYUFk,11363
+matplotlib/tests/test_pyplot.py,sha256=b3ryM3bPeyZ3KYivwexyTbJbt6u27cTFKKKu6q17CCU,13077
+matplotlib/tests/test_quiver.py,sha256=ABpTj72peaKpeSs-UgT1NTD3njMtVrvJ5aNDozpH_P4,10105
+matplotlib/tests/test_rcparams.py,sha256=hdEPjrlEvNnpnFsoLMSm6K9jA-vgsDRpcRiPd5bcIa0,25426
+matplotlib/tests/test_sankey.py,sha256=yg4i-qHT5MljFzFGViOnHbMkumM8bhPwRgoQ5M6CUEs,3900
+matplotlib/tests/test_scale.py,sha256=3jUrfVsyxRE9FpmtWDC-ySo04E26s-ahDL9O3iKeEpQ,8411
+matplotlib/tests/test_simplification.py,sha256=rq5RGw8dSwhCXEr-kUnCqLot_UUGH2JD30xZiIc0RN4,18869
+matplotlib/tests/test_skew.py,sha256=vraGslq4buDkaugNIhK96K6BCswlJ-9ar-vpxFLA-eY,6340
+matplotlib/tests/test_sphinxext.py,sha256=N-mey5MZWVaLxbN1wPvwqisV-u2ewvp9mA0uFQaPSEo,9724
+matplotlib/tests/test_spines.py,sha256=q61XCKIySvm32S3imHA3SR5vVRGFVo-VUCx_LpKN_Fc,4893
+matplotlib/tests/test_streamplot.py,sha256=FeZdKlfXvywlaM_YJp57IPRY-TNji5rklU4UgU1bmro,5723
+matplotlib/tests/test_style.py,sha256=sd6rMLpPBS1hinR2svI1rXZmnXUnMQk1szxSNBUXtzU,6509
+matplotlib/tests/test_subplots.py,sha256=OMgOqLT00zm6KD62jx5iiUJasCRVBU1K8G-6jmjBFiI,10766
+matplotlib/tests/test_table.py,sha256=4H3-8JDKhcev4_lLSLm_HoJdYZuE29T2wm83iicbmos,8103
+matplotlib/tests/test_testing.py,sha256=eh-1r4PIXcM7hfSKCNTU899QxRYWhZBg6W7x0TDVUxo,1057
+matplotlib/tests/test_texmanager.py,sha256=j_5ZG02ztIO-m0oXzd31a13YFw_G7JR7Ldt3fwf-phI,2647
+matplotlib/tests/test_text.py,sha256=7kfcbyqL4uAxHGQl7WgV4RyPTnjAd8Y4zCS2M6tSZVM,38473
+matplotlib/tests/test_textpath.py,sha256=WLXvT5OzE6Tew4pr87LH-cgioCzM7srgMNRemiMEC5o,271
+matplotlib/tests/test_ticker.py,sha256=ncU6yN3mcFpu2HjjjlPZHu230NNfEVyCClxbCx2wNuU,71991
+matplotlib/tests/test_tightlayout.py,sha256=Hzv2oivfF_ajK2VS1yCZqUV0GsOcyYWSPcb5WsClHqo,12731
+matplotlib/tests/test_transforms.py,sha256=MTsHEjZEWW63BnFgoAIgjElBdQ42x5DaVgpkGoL8U_g,46700
+matplotlib/tests/test_triangulation.py,sha256=SlOePrPHzlwKiK9GIOXFkYEvsoO6oOSv3Cwq8ZxjMeI,54943
+matplotlib/tests/test_ttconv.py,sha256=yW3YkGWTh-h9KXcyy70dEH4ytVuhMlzl-HMsNbK_gX8,540
+matplotlib/tests/test_type1font.py,sha256=7TUXy8ehA3el-zvd4U9bnocYbelssDhUeph5cOFoaE4,6369
+matplotlib/tests/test_units.py,sha256=B_4KZi4QE3M-5BXIxvz2Q2iU20II36LJp-XSeyfefyc,10039
+matplotlib/tests/test_usetex.py,sha256=a-Y6NuyROPHDGP2ELsOZNSVwBUoGtAv1xQZfisl9lSE,6405
+matplotlib/tests/test_widgets.py,sha256=RB8RBow51kNGGk1adppF6yQ-bmxSm0akNBTKBrPBL0U,67025
+matplotlib/texmanager.py,sha256=zbnzSYgmoyTB3rapePXvbH9CrLMmxIL3GEPnV2KN1Ys,15098
+matplotlib/texmanager.pyi,sha256=di3gbC9muXKTo5VCrW5ye-e19A1mrOl8e8lvI3b904A,1116
+matplotlib/text.py,sha256=POLIW_kNgJJeuhbz4IgIXTW0MkQLVHgANHXSjVw1dbc,70583
+matplotlib/text.pyi,sha256=LGMi0PLN7hlWeNVyS57bePXGjpXWhIy1AqyS2h7mCak,8027
+matplotlib/textpath.py,sha256=TUyF7xSUzj-6_agCuGl-8kX57hBqsGZIROMHwWAZ1ro,13254
+matplotlib/textpath.pyi,sha256=rqOeTAeQYgm2b2NpetrEX0gMF8PzzW43xS5mNfUA98M,2529
+matplotlib/ticker.py,sha256=nYEBZfZpfR45leflKlkmy2Bmm-CWKjb5K4sIrB2qZ54,104617
+matplotlib/ticker.pyi,sha256=konxZrZgNRz8PpaEHadIVa0WSIdRh5ORisDEuaUzSbA,10208
+matplotlib/transforms.py,sha256=rfr3PQ8jEyscsXPQrGCbGE3gbTvzNi31Xc9-x0ACVKM,100003
+matplotlib/transforms.pyi,sha256=E_I9VfgTtA3Df2mUROfwG-gyvccJ4KOCp3nFt1qWixc,11978
+matplotlib/tri/__init__.py,sha256=asnfefKRpJv7sGbfddCMybnJInVDPwgph7g0mpoh2u4,820
+matplotlib/tri/__pycache__/__init__.cpython-310.pyc,,
+matplotlib/tri/__pycache__/_triangulation.cpython-310.pyc,,
+matplotlib/tri/__pycache__/_tricontour.cpython-310.pyc,,
+matplotlib/tri/__pycache__/_trifinder.cpython-310.pyc,,
+matplotlib/tri/__pycache__/_triinterpolate.cpython-310.pyc,,
+matplotlib/tri/__pycache__/_tripcolor.cpython-310.pyc,,
+matplotlib/tri/__pycache__/_triplot.cpython-310.pyc,,
+matplotlib/tri/__pycache__/_trirefine.cpython-310.pyc,,
+matplotlib/tri/__pycache__/_tritools.cpython-310.pyc,,
+matplotlib/tri/_triangulation.py,sha256=Ur2lKMOx4NrZxwyi0hBeBnVzicuKaCke0NkrZneSklM,9784
+matplotlib/tri/_triangulation.pyi,sha256=pVw1rvpIcl00p7V7E9GcvJSqQWyoxlZXX_p0_VSxTiY,1017
+matplotlib/tri/_tricontour.py,sha256=HFekvmC3eIUG1kw3O6NnyBHSRYjyF8pWqrIXbK53RoA,10239
+matplotlib/tri/_tricontour.pyi,sha256=jnsAmVRX0-FOUw9ptUgci9J4T4JQRloKeH8fh8aAi-o,1155
+matplotlib/tri/_trifinder.py,sha256=3gUzJZDIwfdsSJUE8hIKso9e1-UGvynUN9HxaqC1EEc,3522
+matplotlib/tri/_trifinder.pyi,sha256=dXcZucacAS3Ch6nrDBPh2e3LYZLfZ7VwqpBUBb-vMPo,405
+matplotlib/tri/_triinterpolate.py,sha256=4FtyJSoJpHcFxkSkZHZ1aNengVNWqVKF4l78PgCH8O0,62445
+matplotlib/tri/_triinterpolate.pyi,sha256=SPuetoGqDlE5jo48yQQazqTY4NfcQ3_2ZYqEE6LFkTw,964
+matplotlib/tri/_tripcolor.py,sha256=3j5J67vO3HuTAfnaZm93wyilpmEX-bX4eiJNAsbOZJM,6275
+matplotlib/tri/_tripcolor.pyi,sha256=QsA-A2ohj3r_tAElt2-9pzi47JiU01tNlRPDIptqnh4,1781
+matplotlib/tri/_triplot.py,sha256=jlHSz36Z5S18zBKc639PlSqdhfl7jHol8ExlddJuDI4,3102
+matplotlib/tri/_triplot.pyi,sha256=9USU-BfitrcdQE8yWOUlBX59QBNoHCWivDon9JbDQ0k,446
+matplotlib/tri/_trirefine.py,sha256=NG8bsDhZ5EOxMT-MsEWzJm11ZR3_8CAYHlG53IGi0ps,13178
+matplotlib/tri/_trirefine.pyi,sha256=J_PmjbeI6UbLaeecgj1OCvGe_sr9UUsNK9NGBSlQ320,1056
+matplotlib/tri/_tritools.py,sha256=wC9KVE6UqkWVHpyW9FU4hQdqRVRVmJlhaBF1EXsaD8U,10575
+matplotlib/tri/_tritools.pyi,sha256=XWwwvH2nIAmH8k59aRjnLBVQbTwKvd_FzdsRNASCJMw,402
+matplotlib/typing.py,sha256=CaCkp84zE_7aDG_Ee6mZfI5k4LG60f354orvBrIvLLg,2098
+matplotlib/units.py,sha256=7O-llc8k3GpdotUs2tWcEGgoUHHX-Y7o0R7f-1Jve3k,6429
+matplotlib/widgets.py,sha256=nzcLR5-PaH2KUfLW9V_G38OeEc5wx1VX5m4afv4HMCQ,151735
+matplotlib/widgets.pyi,sha256=rZjyEMCNKR8Xz-igAZj7rxh4ZoOqUzis3SuEIV6qSKs,15375
+mpl_toolkits/axes_grid1/__init__.py,sha256=wiuUCQo1g20SW5T3mFOmI9dGCJY6aDmglpQw5DfszEU,371
+mpl_toolkits/axes_grid1/__pycache__/__init__.cpython-310.pyc,,
+mpl_toolkits/axes_grid1/__pycache__/anchored_artists.cpython-310.pyc,,
+mpl_toolkits/axes_grid1/__pycache__/axes_divider.cpython-310.pyc,,
+mpl_toolkits/axes_grid1/__pycache__/axes_grid.cpython-310.pyc,,
+mpl_toolkits/axes_grid1/__pycache__/axes_rgb.cpython-310.pyc,,
+mpl_toolkits/axes_grid1/__pycache__/axes_size.cpython-310.pyc,,
+mpl_toolkits/axes_grid1/__pycache__/inset_locator.cpython-310.pyc,,
+mpl_toolkits/axes_grid1/__pycache__/mpl_axes.cpython-310.pyc,,
+mpl_toolkits/axes_grid1/__pycache__/parasite_axes.cpython-310.pyc,,
+mpl_toolkits/axes_grid1/anchored_artists.py,sha256=pRyYM69J3iEdIZq5IpbCOQBXD6LbkiE-SPCEh-ZDKw4,19211
+mpl_toolkits/axes_grid1/axes_divider.py,sha256=Q5mdTLc7k5z660u53c-XdfNf_cDSFIGnqp9Tgb3uXJQ,24557
+mpl_toolkits/axes_grid1/axes_grid.py,sha256=4ZOhjLn_29I3Q0QZZbnAjEN7e9MwmW-aydrQC4LqKko,22297
+mpl_toolkits/axes_grid1/axes_rgb.py,sha256=pabgaWJuLTCPw2FlT6Zfy5d0_95CEvaLeosWRTElR98,5227
+mpl_toolkits/axes_grid1/axes_size.py,sha256=ize47FCDCehkvBu1wxoaRt3BRUjubjaQdBjdm92oDZU,7029
+mpl_toolkits/axes_grid1/inset_locator.py,sha256=0FzpYiTGKKHewYFzDGP_giwVm5dMGtdbbDbyjXKqD28,21133
+mpl_toolkits/axes_grid1/mpl_axes.py,sha256=vFCttnj9JIgY3Mt2eOi-O_FVvdZ6SW_sBtIBFib6bz4,4251
+mpl_toolkits/axes_grid1/parasite_axes.py,sha256=T-ve7kZbh3WLKPSr6X7MrFfwN9LaQh71i1ADtJ-Feyk,9416
+mpl_toolkits/axes_grid1/tests/__init__.py,sha256=sKLxL9jEJBX7eh5OumtXSOnTriPrJUkujTHFtnJVFrM,365
+mpl_toolkits/axes_grid1/tests/__pycache__/__init__.cpython-310.pyc,,
+mpl_toolkits/axes_grid1/tests/__pycache__/conftest.cpython-310.pyc,,
+mpl_toolkits/axes_grid1/tests/__pycache__/test_axes_grid1.cpython-310.pyc,,
+mpl_toolkits/axes_grid1/tests/conftest.py,sha256=zB61sy90X97YJ16mIGiuaEAaBIjBEzRAK_qfSCichQM,147
+mpl_toolkits/axes_grid1/tests/test_axes_grid1.py,sha256=VxF-VNnYvad5sqMGMqP0JWbNADCpBtyG8_EO94l5eVc,29401
+mpl_toolkits/axisartist/__init__.py,sha256=RPaNDl22FbmDP7ZRsku1yCqpoNqcclCk0a3rXj3G7fE,631
+mpl_toolkits/axisartist/__pycache__/__init__.cpython-310.pyc,,
+mpl_toolkits/axisartist/__pycache__/angle_helper.cpython-310.pyc,,
+mpl_toolkits/axisartist/__pycache__/axes_divider.cpython-310.pyc,,
+mpl_toolkits/axisartist/__pycache__/axes_grid.cpython-310.pyc,,
+mpl_toolkits/axisartist/__pycache__/axes_rgb.cpython-310.pyc,,
+mpl_toolkits/axisartist/__pycache__/axis_artist.cpython-310.pyc,,
+mpl_toolkits/axisartist/__pycache__/axisline_style.cpython-310.pyc,,
+mpl_toolkits/axisartist/__pycache__/axislines.cpython-310.pyc,,
+mpl_toolkits/axisartist/__pycache__/floating_axes.cpython-310.pyc,,
+mpl_toolkits/axisartist/__pycache__/grid_finder.cpython-310.pyc,,
+mpl_toolkits/axisartist/__pycache__/grid_helper_curvelinear.cpython-310.pyc,,
+mpl_toolkits/axisartist/__pycache__/parasite_axes.cpython-310.pyc,,
+mpl_toolkits/axisartist/angle_helper.py,sha256=-mjKpaR1pLMJuoc0sx0_V3bv0iRPMrpS7r_WI0UYrCc,12952
+mpl_toolkits/axisartist/axes_divider.py,sha256=ltdw9uabafN8MXqTcmtpA2mVFKmDqswCDzPZA6Qp2oo,135
+mpl_toolkits/axisartist/axes_grid.py,sha256=MiF5JTwOy8mKBpicIQk_itM0Mvcaq9-ctdayPR3JQto,593
+mpl_toolkits/axisartist/axes_rgb.py,sha256=gfqcc7N3iAFGfShu1g2516unMj5hvNoeF2YRSJslopQ,532
+mpl_toolkits/axisartist/axis_artist.py,sha256=lzFeyR1RCIvRFv2SCz-FNQHugQjtEMU2rX4fWn7XXnI,38158
+mpl_toolkits/axisartist/axisline_style.py,sha256=9jbDkXEzMQiDHR-lDYKZEvTADtJwt2qlN1cErVUUdx0,6723
+mpl_toolkits/axisartist/axislines.py,sha256=yzP-0k5dkC4jiUmxpADds1Ygl3bPbkCz4c7US_5hs4g,16708
+mpl_toolkits/axisartist/floating_axes.py,sha256=-Zmt33-KlX8h5BXuf_DNE518JV7tOM_A_X7JCae-VkY,10670
+mpl_toolkits/axisartist/grid_finder.py,sha256=Hi2zwnQilavgrqWKScuSRba_WBPqqrbmErGU0XyAsOo,12265
+mpl_toolkits/axisartist/grid_helper_curvelinear.py,sha256=ofN7pPqEMh3r6bSf9eOHkAZEOrmhiNZV-Yig3jozkC4,12349
+mpl_toolkits/axisartist/parasite_axes.py,sha256=Ydi4-0Lbczr6K7Sz1-fRwK4Tm8KlHrOIumx67Xbo_9c,244
+mpl_toolkits/axisartist/tests/__init__.py,sha256=sKLxL9jEJBX7eh5OumtXSOnTriPrJUkujTHFtnJVFrM,365
+mpl_toolkits/axisartist/tests/__pycache__/__init__.cpython-310.pyc,,
+mpl_toolkits/axisartist/tests/__pycache__/conftest.cpython-310.pyc,,
+mpl_toolkits/axisartist/tests/__pycache__/test_angle_helper.cpython-310.pyc,,
+mpl_toolkits/axisartist/tests/__pycache__/test_axis_artist.cpython-310.pyc,,
+mpl_toolkits/axisartist/tests/__pycache__/test_axislines.cpython-310.pyc,,
+mpl_toolkits/axisartist/tests/__pycache__/test_floating_axes.cpython-310.pyc,,
+mpl_toolkits/axisartist/tests/__pycache__/test_grid_finder.cpython-310.pyc,,
+mpl_toolkits/axisartist/tests/__pycache__/test_grid_helper_curvelinear.cpython-310.pyc,,
+mpl_toolkits/axisartist/tests/conftest.py,sha256=zB61sy90X97YJ16mIGiuaEAaBIjBEzRAK_qfSCichQM,147
+mpl_toolkits/axisartist/tests/test_angle_helper.py,sha256=PwhJwBm2kk4uMyhdO5arQs8IlqSX2vN0hvUzI7YHqrw,5670
+mpl_toolkits/axisartist/tests/test_axis_artist.py,sha256=wt3bicVgUPnBX48-dH0Z6hboHgutIgwVpaGkcUZDeVU,2980
+mpl_toolkits/axisartist/tests/test_axislines.py,sha256=fmAVzqSgbLdqtBhq1G0DADySb6Rx5wdgMJUPlfEB-pk,4361
+mpl_toolkits/axisartist/tests/test_floating_axes.py,sha256=l24VB1SLrsJZOMMH2jmBny9ETha4AqAM5KokdGOa5Wk,4083
+mpl_toolkits/axisartist/tests/test_grid_finder.py,sha256=cwQLDOdcJbAY2E7dr8595yzuNh1_Yh80r_O8WGT2hMY,1156
+mpl_toolkits/axisartist/tests/test_grid_helper_curvelinear.py,sha256=OhHej0vCfCjJJknT7yIt4OxZd6OMJCXnFoT3pzqUtTo,7216
+mpl_toolkits/mplot3d/__init__.py,sha256=fH9HdMfFMvjbIWqy2gjQnm2m3ae1CvLiuH6LwKHo0kI,49
+mpl_toolkits/mplot3d/__pycache__/__init__.cpython-310.pyc,,
+mpl_toolkits/mplot3d/__pycache__/art3d.cpython-310.pyc,,
+mpl_toolkits/mplot3d/__pycache__/axes3d.cpython-310.pyc,,
+mpl_toolkits/mplot3d/__pycache__/axis3d.cpython-310.pyc,,
+mpl_toolkits/mplot3d/__pycache__/proj3d.cpython-310.pyc,,
+mpl_toolkits/mplot3d/art3d.py,sha256=B2obITqkuza4uXjPo_YylYTLLl60ZQD-G3FFvCdpYak,43048
+mpl_toolkits/mplot3d/axes3d.py,sha256=_Q_Xj1jqBsjYxt4BqmUfm8QG_QWykvItQdO669-nDIk,141531
+mpl_toolkits/mplot3d/axis3d.py,sha256=VTA4TmBVlsXVqNKYlKGnqsYRRpdaY026eUCdarGKPCk,29809
+mpl_toolkits/mplot3d/proj3d.py,sha256=exvdG39Py5cXCzzfGnLJSvn5MZ-EE-MRRGejMdAW0Aw,6933
+mpl_toolkits/mplot3d/tests/__init__.py,sha256=sKLxL9jEJBX7eh5OumtXSOnTriPrJUkujTHFtnJVFrM,365
+mpl_toolkits/mplot3d/tests/__pycache__/__init__.cpython-310.pyc,,
+mpl_toolkits/mplot3d/tests/__pycache__/conftest.cpython-310.pyc,,
+mpl_toolkits/mplot3d/tests/__pycache__/test_art3d.cpython-310.pyc,,
+mpl_toolkits/mplot3d/tests/__pycache__/test_axes3d.cpython-310.pyc,,
+mpl_toolkits/mplot3d/tests/__pycache__/test_legend3d.cpython-310.pyc,,
+mpl_toolkits/mplot3d/tests/conftest.py,sha256=zB61sy90X97YJ16mIGiuaEAaBIjBEzRAK_qfSCichQM,147
+mpl_toolkits/mplot3d/tests/test_art3d.py,sha256=1XCIo8xuKYxRDs34oxcjT8t2O1zCSFkK3u8Z753s3sk,2182
+mpl_toolkits/mplot3d/tests/test_axes3d.py,sha256=YWtJEdgyP5Cp0-gFatjl8v9ktUosGnJR8EDuC5dnMYA,83231
+mpl_toolkits/mplot3d/tests/test_legend3d.py,sha256=A6CWWz3q5VqYu7WRhwALSWMYkPwj941sQ5GErWLdBZ8,4342
+pylab.py,sha256=zUXU0l7e7C5jmDSJbM0GLQxBun3xzuXNf1tuoZYA6Xk,110

openflamingo/lib/python3.10/site-packages/matplotlib-3.9.4.dist-info/WHEEL

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

openflamingo/lib/python3.10/site-packages/pip/_vendor/certifi/__init__.py

@@ -0,0 +1,4 @@
+from .core import contents, where
+
+__all__ = ["contents", "where"]
+__version__ = "2024.08.30"

openflamingo/lib/python3.10/site-packages/pip/_vendor/certifi/__main__.py

@@ -0,0 +1,12 @@
+import argparse
+
+from pip._vendor.certifi import contents, where
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-c", "--contents", action="store_true")
+args = parser.parse_args()
+
+if args.contents:
+    print(contents())
+else:
+    print(where())

openflamingo/lib/python3.10/site-packages/pip/_vendor/certifi/core.py

@@ -0,0 +1,114 @@
+"""
+certifi.py
+~~~~~~~~~~
+
+This module returns the installation location of cacert.pem or its contents.
+"""
+import sys
+import atexit
+
+def exit_cacert_ctx() -> None:
+    _CACERT_CTX.__exit__(None, None, None)  # type: ignore[union-attr]
+
+
+if sys.version_info >= (3, 11):
+
+    from importlib.resources import as_file, files
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the file
+        # in cases where we're inside of a zipimport situation until someone
+        # actually calls where(), but we don't want to re-extract the file
+        # on every call of where(), so we'll do it once then store it in a
+        # global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you to
+            # manage the cleanup of this file, so it doesn't actually return a
+            # path, it returns a context manager that will give you the path
+            # when you enter it and will do any cleanup when you leave it. In
+            # the common case of not needing a temporary file, it will just
+            # return the file system location and the __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = as_file(files("pip._vendor.certifi").joinpath("cacert.pem"))
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+            atexit.register(exit_cacert_ctx)
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return files("pip._vendor.certifi").joinpath("cacert.pem").read_text(encoding="ascii")
+
+elif sys.version_info >= (3, 7):
+
+    from importlib.resources import path as get_path, read_text
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the
+        # file in cases where we're inside of a zipimport situation until
+        # someone actually calls where(), but we don't want to re-extract
+        # the file on every call of where(), so we'll do it once then store
+        # it in a global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you
+            # to manage the cleanup of this file, so it doesn't actually
+            # return a path, it returns a context manager that will give
+            # you the path when you enter it and will do any cleanup when
+            # you leave it. In the common case of not needing a temporary
+            # file, it will just return the file system location and the
+            # __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = get_path("pip._vendor.certifi", "cacert.pem")
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+            atexit.register(exit_cacert_ctx)
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return read_text("pip._vendor.certifi", "cacert.pem", encoding="ascii")
+
+else:
+    import os
+    import types
+    from typing import Union
+
+    Package = Union[types.ModuleType, str]
+    Resource = Union[str, "os.PathLike"]
+
+    # This fallback will work for Python versions prior to 3.7 that lack the
+    # importlib.resources module but relies on the existing `where` function
+    # so won't address issues with environments like PyOxidizer that don't set
+    # __file__ on modules.
+    def read_text(
+        package: Package,
+        resource: Resource,
+        encoding: str = 'utf-8',
+        errors: str = 'strict'
+    ) -> str:
+        with open(where(), encoding=encoding) as data:
+            return data.read()
+
+    # If we don't have importlib.resources, then we will just do the old logic
+    # of assuming we're on the filesystem and munge the path directly.
+    def where() -> str:
+        f = os.path.dirname(__file__)
+
+        return os.path.join(f, "cacert.pem")
+
+    def contents() -> str:
+        return read_text("pip._vendor.certifi", "cacert.pem", encoding="ascii")

openflamingo/lib/python3.10/site-packages/pip/_vendor/distlib/w64-arm.exe

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

openflamingo/lib/python3.10/site-packages/pip/_vendor/truststore/__init__.py

@@ -0,0 +1,36 @@
+"""Verify certificates using native system trust stores"""
+
+import sys as _sys
+
+if _sys.version_info < (3, 10):
+    raise ImportError("truststore requires Python 3.10 or later")
+
+# Detect Python runtimes which don't implement SSLObject.get_unverified_chain() API
+# This API only became public in Python 3.13 but was available in CPython and PyPy since 3.10.
+if _sys.version_info < (3, 13):
+    try:
+        import ssl as _ssl
+    except ImportError:
+        raise ImportError("truststore requires the 'ssl' module")
+    else:
+        _sslmem = _ssl.MemoryBIO()
+        _sslobj = _ssl.create_default_context().wrap_bio(
+            _sslmem,
+            _sslmem,
+        )
+        try:
+            while not hasattr(_sslobj, "get_unverified_chain"):
+                _sslobj = _sslobj._sslobj  # type: ignore[attr-defined]
+        except AttributeError:
+            raise ImportError(
+                "truststore requires peer certificate chain APIs to be available"
+            ) from None
+
+        del _ssl, _sslobj, _sslmem  # noqa: F821
+
+from ._api import SSLContext, extract_from_ssl, inject_into_ssl  # noqa: E402
+
+del _api, _sys  # type: ignore[name-defined] # noqa: F821
+
+__all__ = ["SSLContext", "inject_into_ssl", "extract_from_ssl"]
+__version__ = "0.10.0"

openflamingo/lib/python3.10/site-packages/pip/_vendor/truststore/_api.py

@@ -0,0 +1,316 @@
+import os
+import platform
+import socket
+import ssl
+import sys
+import typing
+
+import _ssl  # type: ignore[import-not-found]
+
+from ._ssl_constants import (
+    _original_SSLContext,
+    _original_super_SSLContext,
+    _truststore_SSLContext_dunder_class,
+    _truststore_SSLContext_super_class,
+)
+
+if platform.system() == "Windows":
+    from ._windows import _configure_context, _verify_peercerts_impl
+elif platform.system() == "Darwin":
+    from ._macos import _configure_context, _verify_peercerts_impl
+else:
+    from ._openssl import _configure_context, _verify_peercerts_impl
+
+if typing.TYPE_CHECKING:
+    from pip._vendor.typing_extensions import Buffer
+
+# From typeshed/stdlib/ssl.pyi
+_StrOrBytesPath: typing.TypeAlias = str | bytes | os.PathLike[str] | os.PathLike[bytes]
+_PasswordType: typing.TypeAlias = str | bytes | typing.Callable[[], str | bytes]
+
+
+def inject_into_ssl() -> None:
+    """Injects the :class:`truststore.SSLContext` into the ``ssl``
+    module by replacing :class:`ssl.SSLContext`.
+    """
+    setattr(ssl, "SSLContext", SSLContext)
+    # urllib3 holds on to its own reference of ssl.SSLContext
+    # so we need to replace that reference too.
+    try:
+        import pip._vendor.urllib3.util.ssl_ as urllib3_ssl
+
+        setattr(urllib3_ssl, "SSLContext", SSLContext)
+    except ImportError:
+        pass
+
+
+def extract_from_ssl() -> None:
+    """Restores the :class:`ssl.SSLContext` class to its original state"""
+    setattr(ssl, "SSLContext", _original_SSLContext)
+    try:
+        import pip._vendor.urllib3.util.ssl_ as urllib3_ssl
+
+        urllib3_ssl.SSLContext = _original_SSLContext  # type: ignore[assignment]
+    except ImportError:
+        pass
+
+
+class SSLContext(_truststore_SSLContext_super_class):  # type: ignore[misc]
+    """SSLContext API that uses system certificates on all platforms"""
+
+    @property  # type: ignore[misc]
+    def __class__(self) -> type:
+        # Dirty hack to get around isinstance() checks
+        # for ssl.SSLContext instances in aiohttp/trustme
+        # when using non-CPython implementations.
+        return _truststore_SSLContext_dunder_class or SSLContext
+
+    def __init__(self, protocol: int = None) -> None:  # type: ignore[assignment]
+        self._ctx = _original_SSLContext(protocol)
+
+        class TruststoreSSLObject(ssl.SSLObject):
+            # This object exists because wrap_bio() doesn't
+            # immediately do the handshake so we need to do
+            # certificate verifications after SSLObject.do_handshake()
+
+            def do_handshake(self) -> None:
+                ret = super().do_handshake()
+                _verify_peercerts(self, server_hostname=self.server_hostname)
+                return ret
+
+        self._ctx.sslobject_class = TruststoreSSLObject
+
+    def wrap_socket(
+        self,
+        sock: socket.socket,
+        server_side: bool = False,
+        do_handshake_on_connect: bool = True,
+        suppress_ragged_eofs: bool = True,
+        server_hostname: str | None = None,
+        session: ssl.SSLSession | None = None,
+    ) -> ssl.SSLSocket:
+        # Use a context manager here because the
+        # inner SSLContext holds on to our state
+        # but also does the actual handshake.
+        with _configure_context(self._ctx):
+            ssl_sock = self._ctx.wrap_socket(
+                sock,
+                server_side=server_side,
+                server_hostname=server_hostname,
+                do_handshake_on_connect=do_handshake_on_connect,
+                suppress_ragged_eofs=suppress_ragged_eofs,
+                session=session,
+            )
+        try:
+            _verify_peercerts(ssl_sock, server_hostname=server_hostname)
+        except Exception:
+            ssl_sock.close()
+            raise
+        return ssl_sock
+
+    def wrap_bio(
+        self,
+        incoming: ssl.MemoryBIO,
+        outgoing: ssl.MemoryBIO,
+        server_side: bool = False,
+        server_hostname: str | None = None,
+        session: ssl.SSLSession | None = None,
+    ) -> ssl.SSLObject:
+        with _configure_context(self._ctx):
+            ssl_obj = self._ctx.wrap_bio(
+                incoming,
+                outgoing,
+                server_hostname=server_hostname,
+                server_side=server_side,
+                session=session,
+            )
+        return ssl_obj
+
+    def load_verify_locations(
+        self,
+        cafile: str | bytes | os.PathLike[str] | os.PathLike[bytes] | None = None,
+        capath: str | bytes | os.PathLike[str] | os.PathLike[bytes] | None = None,
+        cadata: typing.Union[str, "Buffer", None] = None,
+    ) -> None:
+        return self._ctx.load_verify_locations(
+            cafile=cafile, capath=capath, cadata=cadata
+        )
+
+    def load_cert_chain(
+        self,
+        certfile: _StrOrBytesPath,
+        keyfile: _StrOrBytesPath | None = None,
+        password: _PasswordType | None = None,
+    ) -> None:
+        return self._ctx.load_cert_chain(
+            certfile=certfile, keyfile=keyfile, password=password
+        )
+
+    def load_default_certs(
+        self, purpose: ssl.Purpose = ssl.Purpose.SERVER_AUTH
+    ) -> None:
+        return self._ctx.load_default_certs(purpose)
+
+    def set_alpn_protocols(self, alpn_protocols: typing.Iterable[str]) -> None:
+        return self._ctx.set_alpn_protocols(alpn_protocols)
+
+    def set_npn_protocols(self, npn_protocols: typing.Iterable[str]) -> None:
+        return self._ctx.set_npn_protocols(npn_protocols)
+
+    def set_ciphers(self, __cipherlist: str) -> None:
+        return self._ctx.set_ciphers(__cipherlist)
+
+    def get_ciphers(self) -> typing.Any:
+        return self._ctx.get_ciphers()
+
+    def session_stats(self) -> dict[str, int]:
+        return self._ctx.session_stats()
+
+    def cert_store_stats(self) -> dict[str, int]:
+        raise NotImplementedError()
+
+    def set_default_verify_paths(self) -> None:
+        self._ctx.set_default_verify_paths()
+
+    @typing.overload
+    def get_ca_certs(
+        self, binary_form: typing.Literal[False] = ...
+    ) -> list[typing.Any]: ...
+
+    @typing.overload
+    def get_ca_certs(self, binary_form: typing.Literal[True] = ...) -> list[bytes]: ...
+
+    @typing.overload
+    def get_ca_certs(self, binary_form: bool = ...) -> typing.Any: ...
+
+    def get_ca_certs(self, binary_form: bool = False) -> list[typing.Any] | list[bytes]:
+        raise NotImplementedError()
+
+    @property
+    def check_hostname(self) -> bool:
+        return self._ctx.check_hostname
+
+    @check_hostname.setter
+    def check_hostname(self, value: bool) -> None:
+        self._ctx.check_hostname = value
+
+    @property
+    def hostname_checks_common_name(self) -> bool:
+        return self._ctx.hostname_checks_common_name
+
+    @hostname_checks_common_name.setter
+    def hostname_checks_common_name(self, value: bool) -> None:
+        self._ctx.hostname_checks_common_name = value
+
+    @property
+    def keylog_filename(self) -> str:
+        return self._ctx.keylog_filename
+
+    @keylog_filename.setter
+    def keylog_filename(self, value: str) -> None:
+        self._ctx.keylog_filename = value
+
+    @property
+    def maximum_version(self) -> ssl.TLSVersion:
+        return self._ctx.maximum_version
+
+    @maximum_version.setter
+    def maximum_version(self, value: ssl.TLSVersion) -> None:
+        _original_super_SSLContext.maximum_version.__set__(  # type: ignore[attr-defined]
+            self._ctx, value
+        )
+
+    @property
+    def minimum_version(self) -> ssl.TLSVersion:
+        return self._ctx.minimum_version
+
+    @minimum_version.setter
+    def minimum_version(self, value: ssl.TLSVersion) -> None:
+        _original_super_SSLContext.minimum_version.__set__(  # type: ignore[attr-defined]
+            self._ctx, value
+        )
+
+    @property
+    def options(self) -> ssl.Options:
+        return self._ctx.options
+
+    @options.setter
+    def options(self, value: ssl.Options) -> None:
+        _original_super_SSLContext.options.__set__(  # type: ignore[attr-defined]
+            self._ctx, value
+        )
+
+    @property
+    def post_handshake_auth(self) -> bool:
+        return self._ctx.post_handshake_auth
+
+    @post_handshake_auth.setter
+    def post_handshake_auth(self, value: bool) -> None:
+        self._ctx.post_handshake_auth = value
+
+    @property
+    def protocol(self) -> ssl._SSLMethod:
+        return self._ctx.protocol
+
+    @property
+    def security_level(self) -> int:
+        return self._ctx.security_level
+
+    @property
+    def verify_flags(self) -> ssl.VerifyFlags:
+        return self._ctx.verify_flags
+
+    @verify_flags.setter
+    def verify_flags(self, value: ssl.VerifyFlags) -> None:
+        _original_super_SSLContext.verify_flags.__set__(  # type: ignore[attr-defined]
+            self._ctx, value
+        )
+
+    @property
+    def verify_mode(self) -> ssl.VerifyMode:
+        return self._ctx.verify_mode
+
+    @verify_mode.setter
+    def verify_mode(self, value: ssl.VerifyMode) -> None:
+        _original_super_SSLContext.verify_mode.__set__(  # type: ignore[attr-defined]
+            self._ctx, value
+        )
+
+
+# Python 3.13+ makes get_unverified_chain() a public API that only returns DER
+# encoded certificates. We detect whether we need to call public_bytes() for 3.10->3.12
+# Pre-3.13 returned None instead of an empty list from get_unverified_chain()
+if sys.version_info >= (3, 13):
+
+    def _get_unverified_chain_bytes(sslobj: ssl.SSLObject) -> list[bytes]:
+        unverified_chain = sslobj.get_unverified_chain() or ()  # type: ignore[attr-defined]
+        return [
+            cert if isinstance(cert, bytes) else cert.public_bytes(_ssl.ENCODING_DER)
+            for cert in unverified_chain
+        ]
+
+else:
+
+    def _get_unverified_chain_bytes(sslobj: ssl.SSLObject) -> list[bytes]:
+        unverified_chain = sslobj.get_unverified_chain() or ()  # type: ignore[attr-defined]
+        return [cert.public_bytes(_ssl.ENCODING_DER) for cert in unverified_chain]
+
+
+def _verify_peercerts(
+    sock_or_sslobj: ssl.SSLSocket | ssl.SSLObject, server_hostname: str | None
+) -> None:
+    """
+    Verifies the peer certificates from an SSLSocket or SSLObject
+    against the certificates in the OS trust store.
+    """
+    sslobj: ssl.SSLObject = sock_or_sslobj  # type: ignore[assignment]
+    try:
+        while not hasattr(sslobj, "get_unverified_chain"):
+            sslobj = sslobj._sslobj  # type: ignore[attr-defined]
+    except AttributeError:
+        pass
+
+    cert_bytes = _get_unverified_chain_bytes(sslobj)
+    _verify_peercerts_impl(
+        sock_or_sslobj.context, cert_bytes, server_hostname=server_hostname
+    )

openflamingo/lib/python3.10/site-packages/pip/_vendor/truststore/_macos.py

@@ -0,0 +1,571 @@
+import contextlib
+import ctypes
+import platform
+import ssl
+import typing
+from ctypes import (
+    CDLL,
+    POINTER,
+    c_bool,
+    c_char_p,
+    c_int32,
+    c_long,
+    c_uint32,
+    c_ulong,
+    c_void_p,
+)
+from ctypes.util import find_library
+
+from ._ssl_constants import _set_ssl_context_verify_mode
+
+_mac_version = platform.mac_ver()[0]
+_mac_version_info = tuple(map(int, _mac_version.split(".")))
+if _mac_version_info < (10, 8):
+    raise ImportError(
+        f"Only OS X 10.8 and newer are supported, not {_mac_version_info[0]}.{_mac_version_info[1]}"
+    )
+
+_is_macos_version_10_14_or_later = _mac_version_info >= (10, 14)
+
+
+def _load_cdll(name: str, macos10_16_path: str) -> CDLL:
+    """Loads a CDLL by name, falling back to known path on 10.16+"""
+    try:
+        # Big Sur is technically 11 but we use 10.16 due to the Big Sur
+        # beta being labeled as 10.16.
+        path: str | None
+        if _mac_version_info >= (10, 16):
+            path = macos10_16_path
+        else:
+            path = find_library(name)
+        if not path:
+            raise OSError  # Caught and reraised as 'ImportError'
+        return CDLL(path, use_errno=True)
+    except OSError:
+        raise ImportError(f"The library {name} failed to load") from None
+
+
+Security = _load_cdll(
+    "Security", "/System/Library/Frameworks/Security.framework/Security"
+)
+CoreFoundation = _load_cdll(
+    "CoreFoundation",
+    "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation",
+)
+
+Boolean = c_bool
+CFIndex = c_long
+CFStringEncoding = c_uint32
+CFData = c_void_p
+CFString = c_void_p
+CFArray = c_void_p
+CFMutableArray = c_void_p
+CFError = c_void_p
+CFType = c_void_p
+CFTypeID = c_ulong
+CFTypeRef = POINTER(CFType)
+CFAllocatorRef = c_void_p
+
+OSStatus = c_int32
+
+CFErrorRef = POINTER(CFError)
+CFDataRef = POINTER(CFData)
+CFStringRef = POINTER(CFString)
+CFArrayRef = POINTER(CFArray)
+CFMutableArrayRef = POINTER(CFMutableArray)
+CFArrayCallBacks = c_void_p
+CFOptionFlags = c_uint32
+
+SecCertificateRef = POINTER(c_void_p)
+SecPolicyRef = POINTER(c_void_p)
+SecTrustRef = POINTER(c_void_p)
+SecTrustResultType = c_uint32
+SecTrustOptionFlags = c_uint32
+
+try:
+    Security.SecCertificateCreateWithData.argtypes = [CFAllocatorRef, CFDataRef]
+    Security.SecCertificateCreateWithData.restype = SecCertificateRef
+
+    Security.SecCertificateCopyData.argtypes = [SecCertificateRef]
+    Security.SecCertificateCopyData.restype = CFDataRef
+
+    Security.SecCopyErrorMessageString.argtypes = [OSStatus, c_void_p]
+    Security.SecCopyErrorMessageString.restype = CFStringRef
+
+    Security.SecTrustSetAnchorCertificates.argtypes = [SecTrustRef, CFArrayRef]
+    Security.SecTrustSetAnchorCertificates.restype = OSStatus
+
+    Security.SecTrustSetAnchorCertificatesOnly.argtypes = [SecTrustRef, Boolean]
+    Security.SecTrustSetAnchorCertificatesOnly.restype = OSStatus
+
+    Security.SecPolicyCreateRevocation.argtypes = [CFOptionFlags]
+    Security.SecPolicyCreateRevocation.restype = SecPolicyRef
+
+    Security.SecPolicyCreateSSL.argtypes = [Boolean, CFStringRef]
+    Security.SecPolicyCreateSSL.restype = SecPolicyRef
+
+    Security.SecTrustCreateWithCertificates.argtypes = [
+        CFTypeRef,
+        CFTypeRef,
+        POINTER(SecTrustRef),
+    ]
+    Security.SecTrustCreateWithCertificates.restype = OSStatus
+
+    Security.SecTrustGetTrustResult.argtypes = [
+        SecTrustRef,
+        POINTER(SecTrustResultType),
+    ]
+    Security.SecTrustGetTrustResult.restype = OSStatus
+
+    Security.SecTrustEvaluate.argtypes = [
+        SecTrustRef,
+        POINTER(SecTrustResultType),
+    ]
+    Security.SecTrustEvaluate.restype = OSStatus
+
+    Security.SecTrustRef = SecTrustRef  # type: ignore[attr-defined]
+    Security.SecTrustResultType = SecTrustResultType  # type: ignore[attr-defined]
+    Security.OSStatus = OSStatus  # type: ignore[attr-defined]
+
+    kSecRevocationUseAnyAvailableMethod = 3
+    kSecRevocationRequirePositiveResponse = 8
+
+    CoreFoundation.CFRelease.argtypes = [CFTypeRef]
+    CoreFoundation.CFRelease.restype = None
+
+    CoreFoundation.CFGetTypeID.argtypes = [CFTypeRef]
+    CoreFoundation.CFGetTypeID.restype = CFTypeID
+
+    CoreFoundation.CFStringCreateWithCString.argtypes = [
+        CFAllocatorRef,
+        c_char_p,
+        CFStringEncoding,
+    ]
+    CoreFoundation.CFStringCreateWithCString.restype = CFStringRef
+
+    CoreFoundation.CFStringGetCStringPtr.argtypes = [CFStringRef, CFStringEncoding]
+    CoreFoundation.CFStringGetCStringPtr.restype = c_char_p
+
+    CoreFoundation.CFStringGetCString.argtypes = [
+        CFStringRef,
+        c_char_p,
+        CFIndex,
+        CFStringEncoding,
+    ]
+    CoreFoundation.CFStringGetCString.restype = c_bool
+
+    CoreFoundation.CFDataCreate.argtypes = [CFAllocatorRef, c_char_p, CFIndex]
+    CoreFoundation.CFDataCreate.restype = CFDataRef
+
+    CoreFoundation.CFDataGetLength.argtypes = [CFDataRef]
+    CoreFoundation.CFDataGetLength.restype = CFIndex
+
+    CoreFoundation.CFDataGetBytePtr.argtypes = [CFDataRef]
+    CoreFoundation.CFDataGetBytePtr.restype = c_void_p
+
+    CoreFoundation.CFArrayCreate.argtypes = [
+        CFAllocatorRef,
+        POINTER(CFTypeRef),
+        CFIndex,
+        CFArrayCallBacks,
+    ]
+    CoreFoundation.CFArrayCreate.restype = CFArrayRef
+
+    CoreFoundation.CFArrayCreateMutable.argtypes = [
+        CFAllocatorRef,
+        CFIndex,
+        CFArrayCallBacks,
+    ]
+    CoreFoundation.CFArrayCreateMutable.restype = CFMutableArrayRef
+
+    CoreFoundation.CFArrayAppendValue.argtypes = [CFMutableArrayRef, c_void_p]
+    CoreFoundation.CFArrayAppendValue.restype = None
+
+    CoreFoundation.CFArrayGetCount.argtypes = [CFArrayRef]
+    CoreFoundation.CFArrayGetCount.restype = CFIndex
+
+    CoreFoundation.CFArrayGetValueAtIndex.argtypes = [CFArrayRef, CFIndex]
+    CoreFoundation.CFArrayGetValueAtIndex.restype = c_void_p
+
+    CoreFoundation.CFErrorGetCode.argtypes = [CFErrorRef]
+    CoreFoundation.CFErrorGetCode.restype = CFIndex
+
+    CoreFoundation.CFErrorCopyDescription.argtypes = [CFErrorRef]
+    CoreFoundation.CFErrorCopyDescription.restype = CFStringRef
+
+    CoreFoundation.kCFAllocatorDefault = CFAllocatorRef.in_dll(  # type: ignore[attr-defined]
+        CoreFoundation, "kCFAllocatorDefault"
+    )
+    CoreFoundation.kCFTypeArrayCallBacks = c_void_p.in_dll(  # type: ignore[attr-defined]
+        CoreFoundation, "kCFTypeArrayCallBacks"
+    )
+
+    CoreFoundation.CFTypeRef = CFTypeRef  # type: ignore[attr-defined]
+    CoreFoundation.CFArrayRef = CFArrayRef  # type: ignore[attr-defined]
+    CoreFoundation.CFStringRef = CFStringRef  # type: ignore[attr-defined]
+    CoreFoundation.CFErrorRef = CFErrorRef  # type: ignore[attr-defined]
+
+except AttributeError as e:
+    raise ImportError(f"Error initializing ctypes: {e}") from None
+
+# SecTrustEvaluateWithError is macOS 10.14+
+if _is_macos_version_10_14_or_later:
+    try:
+        Security.SecTrustEvaluateWithError.argtypes = [
+            SecTrustRef,
+            POINTER(CFErrorRef),
+        ]
+        Security.SecTrustEvaluateWithError.restype = c_bool
+    except AttributeError as e:
+        raise ImportError(f"Error initializing ctypes: {e}") from None
+
+
+def _handle_osstatus(result: OSStatus, _: typing.Any, args: typing.Any) -> typing.Any:
+    """
+    Raises an error if the OSStatus value is non-zero.
+    """
+    if int(result) == 0:
+        return args
+
+    # Returns a CFString which we need to transform
+    # into a UTF-8 Python string.
+    error_message_cfstring = None
+    try:
+        error_message_cfstring = Security.SecCopyErrorMessageString(result, None)
+
+        # First step is convert the CFString into a C string pointer.
+        # We try the fast no-copy way first.
+        error_message_cfstring_c_void_p = ctypes.cast(
+            error_message_cfstring, ctypes.POINTER(ctypes.c_void_p)
+        )
+        message = CoreFoundation.CFStringGetCStringPtr(
+            error_message_cfstring_c_void_p, CFConst.kCFStringEncodingUTF8
+        )
+
+        # Quoting the Apple dev docs:
+        #
+        # "A pointer to a C string or NULL if the internal
+        # storage of theString does not allow this to be
+        # returned efficiently."
+        #
+        # So we need to get our hands dirty.
+        if message is None:
+            buffer = ctypes.create_string_buffer(1024)
+            result = CoreFoundation.CFStringGetCString(
+                error_message_cfstring_c_void_p,
+                buffer,
+                1024,
+                CFConst.kCFStringEncodingUTF8,
+            )
+            if not result:
+                raise OSError("Error copying C string from CFStringRef")
+            message = buffer.value
+
+    finally:
+        if error_message_cfstring is not None:
+            CoreFoundation.CFRelease(error_message_cfstring)
+
+    # If no message can be found for this status we come
+    # up with a generic one that forwards the status code.
+    if message is None or message == "":
+        message = f"SecureTransport operation returned a non-zero OSStatus: {result}"
+
+    raise ssl.SSLError(message)
+
+
+Security.SecTrustCreateWithCertificates.errcheck = _handle_osstatus  # type: ignore[assignment]
+Security.SecTrustSetAnchorCertificates.errcheck = _handle_osstatus  # type: ignore[assignment]
+Security.SecTrustSetAnchorCertificatesOnly.errcheck = _handle_osstatus  # type: ignore[assignment]
+Security.SecTrustGetTrustResult.errcheck = _handle_osstatus  # type: ignore[assignment]
+Security.SecTrustEvaluate.errcheck = _handle_osstatus  # type: ignore[assignment]
+
+
+class CFConst:
+    """CoreFoundation constants"""
+
+    kCFStringEncodingUTF8 = CFStringEncoding(0x08000100)
+
+    errSecIncompleteCertRevocationCheck = -67635
+    errSecHostNameMismatch = -67602
+    errSecCertificateExpired = -67818
+    errSecNotTrusted = -67843
+
+
+def _bytes_to_cf_data_ref(value: bytes) -> CFDataRef:  # type: ignore[valid-type]
+    return CoreFoundation.CFDataCreate(  # type: ignore[no-any-return]
+        CoreFoundation.kCFAllocatorDefault, value, len(value)
+    )
+
+
+def _bytes_to_cf_string(value: bytes) -> CFString:
+    """
+    Given a Python binary data, create a CFString.
+    The string must be CFReleased by the caller.
+    """
+    c_str = ctypes.c_char_p(value)
+    cf_str = CoreFoundation.CFStringCreateWithCString(
+        CoreFoundation.kCFAllocatorDefault,
+        c_str,
+        CFConst.kCFStringEncodingUTF8,
+    )
+    return cf_str  # type: ignore[no-any-return]
+
+
+def _cf_string_ref_to_str(cf_string_ref: CFStringRef) -> str | None:  # type: ignore[valid-type]
+    """
+    Creates a Unicode string from a CFString object. Used entirely for error
+    reporting.
+    Yes, it annoys me quite a lot that this function is this complex.
+    """
+
+    string = CoreFoundation.CFStringGetCStringPtr(
+        cf_string_ref, CFConst.kCFStringEncodingUTF8
+    )
+    if string is None:
+        buffer = ctypes.create_string_buffer(1024)
+        result = CoreFoundation.CFStringGetCString(
+            cf_string_ref, buffer, 1024, CFConst.kCFStringEncodingUTF8
+        )
+        if not result:
+            raise OSError("Error copying C string from CFStringRef")
+        string = buffer.value
+    if string is not None:
+        string = string.decode("utf-8")
+    return string  # type: ignore[no-any-return]
+
+
+def _der_certs_to_cf_cert_array(certs: list[bytes]) -> CFMutableArrayRef:  # type: ignore[valid-type]
+    """Builds a CFArray of SecCertificateRefs from a list of DER-encoded certificates.
+    Responsibility of the caller to call CoreFoundation.CFRelease on the CFArray.
+    """
+    cf_array = CoreFoundation.CFArrayCreateMutable(
+        CoreFoundation.kCFAllocatorDefault,
+        0,
+        ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks),
+    )
+    if not cf_array:
+        raise MemoryError("Unable to allocate memory!")
+
+    for cert_data in certs:
+        cf_data = None
+        sec_cert_ref = None
+        try:
+            cf_data = _bytes_to_cf_data_ref(cert_data)
+            sec_cert_ref = Security.SecCertificateCreateWithData(
+                CoreFoundation.kCFAllocatorDefault, cf_data
+            )
+            CoreFoundation.CFArrayAppendValue(cf_array, sec_cert_ref)
+        finally:
+            if cf_data:
+                CoreFoundation.CFRelease(cf_data)
+            if sec_cert_ref:
+                CoreFoundation.CFRelease(sec_cert_ref)
+
+    return cf_array  # type: ignore[no-any-return]
+
+
+@contextlib.contextmanager
+def _configure_context(ctx: ssl.SSLContext) -> typing.Iterator[None]:
+    check_hostname = ctx.check_hostname
+    verify_mode = ctx.verify_mode
+    ctx.check_hostname = False
+    _set_ssl_context_verify_mode(ctx, ssl.CERT_NONE)
+    try:
+        yield
+    finally:
+        ctx.check_hostname = check_hostname
+        _set_ssl_context_verify_mode(ctx, verify_mode)
+
+
+def _verify_peercerts_impl(
+    ssl_context: ssl.SSLContext,
+    cert_chain: list[bytes],
+    server_hostname: str | None = None,
+) -> None:
+    certs = None
+    policies = None
+    trust = None
+    try:
+        # Only set a hostname on the policy if we're verifying the hostname
+        # on the leaf certificate.
+        if server_hostname is not None and ssl_context.check_hostname:
+            cf_str_hostname = None
+            try:
+                cf_str_hostname = _bytes_to_cf_string(server_hostname.encode("ascii"))
+                ssl_policy = Security.SecPolicyCreateSSL(True, cf_str_hostname)
+            finally:
+                if cf_str_hostname:
+                    CoreFoundation.CFRelease(cf_str_hostname)
+        else:
+            ssl_policy = Security.SecPolicyCreateSSL(True, None)
+
+        policies = ssl_policy
+        if ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_CHAIN:
+            # Add explicit policy requiring positive revocation checks
+            policies = CoreFoundation.CFArrayCreateMutable(
+                CoreFoundation.kCFAllocatorDefault,
+                0,
+                ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks),
+            )
+            CoreFoundation.CFArrayAppendValue(policies, ssl_policy)
+            CoreFoundation.CFRelease(ssl_policy)
+            revocation_policy = Security.SecPolicyCreateRevocation(
+                kSecRevocationUseAnyAvailableMethod
+                | kSecRevocationRequirePositiveResponse
+            )
+            CoreFoundation.CFArrayAppendValue(policies, revocation_policy)
+            CoreFoundation.CFRelease(revocation_policy)
+        elif ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_LEAF:
+            raise NotImplementedError("VERIFY_CRL_CHECK_LEAF not implemented for macOS")
+
+        certs = None
+        try:
+            certs = _der_certs_to_cf_cert_array(cert_chain)
+
+            # Now that we have certificates loaded and a SecPolicy
+            # we can finally create a SecTrust object!
+            trust = Security.SecTrustRef()
+            Security.SecTrustCreateWithCertificates(
+                certs, policies, ctypes.byref(trust)
+            )
+
+        finally:
+            # The certs are now being held by SecTrust so we can
+            # release our handles for the array.
+            if certs:
+                CoreFoundation.CFRelease(certs)
+
+        # If there are additional trust anchors to load we need to transform
+        # the list of DER-encoded certificates into a CFArray.
+        ctx_ca_certs_der: list[bytes] | None = ssl_context.get_ca_certs(
+            binary_form=True
+        )
+        if ctx_ca_certs_der:
+            ctx_ca_certs = None
+            try:
+                ctx_ca_certs = _der_certs_to_cf_cert_array(ctx_ca_certs_der)
+                Security.SecTrustSetAnchorCertificates(trust, ctx_ca_certs)
+            finally:
+                if ctx_ca_certs:
+                    CoreFoundation.CFRelease(ctx_ca_certs)
+
+        # We always want system certificates.
+        Security.SecTrustSetAnchorCertificatesOnly(trust, False)
+
+        # macOS 10.13 and earlier don't support SecTrustEvaluateWithError()
+        # so we use SecTrustEvaluate() which means we need to construct error
+        # messages ourselves.
+        if _is_macos_version_10_14_or_later:
+            _verify_peercerts_impl_macos_10_14(ssl_context, trust)
+        else:
+            _verify_peercerts_impl_macos_10_13(ssl_context, trust)
+    finally:
+        if policies:
+            CoreFoundation.CFRelease(policies)
+        if trust:
+            CoreFoundation.CFRelease(trust)
+
+
+def _verify_peercerts_impl_macos_10_13(
+    ssl_context: ssl.SSLContext, sec_trust_ref: typing.Any
+) -> None:
+    """Verify using 'SecTrustEvaluate' API for macOS 10.13 and earlier.
+    macOS 10.14 added the 'SecTrustEvaluateWithError' API.
+    """
+    sec_trust_result_type = Security.SecTrustResultType()
+    Security.SecTrustEvaluate(sec_trust_ref, ctypes.byref(sec_trust_result_type))
+
+    try:
+        sec_trust_result_type_as_int = int(sec_trust_result_type.value)
+    except (ValueError, TypeError):
+        sec_trust_result_type_as_int = -1
+
+    # Apple doesn't document these values in their own API docs.
+    # See: https://github.com/xybp888/iOS-SDKs/blob/master/iPhoneOS13.0.sdk/System/Library/Frameworks/Security.framework/Headers/SecTrust.h#L84
+    if (
+        ssl_context.verify_mode == ssl.CERT_REQUIRED
+        and sec_trust_result_type_as_int not in (1, 4)
+    ):
+        # Note that we're not able to ignore only hostname errors
+        # for macOS 10.13 and earlier, so check_hostname=False will
+        # still return an error.
+        sec_trust_result_type_to_message = {
+            0: "Invalid trust result type",
+            # 1: "Trust evaluation succeeded",
+            2: "User confirmation required",
+            3: "User specified that certificate is not trusted",
+            # 4: "Trust result is unspecified",
+            5: "Recoverable trust failure occurred",
+            6: "Fatal trust failure occurred",
+            7: "Other error occurred, certificate may be revoked",
+        }
+        error_message = sec_trust_result_type_to_message.get(
+            sec_trust_result_type_as_int,
+            f"Unknown trust result: {sec_trust_result_type_as_int}",
+        )
+
+        err = ssl.SSLCertVerificationError(error_message)
+        err.verify_message = error_message
+        err.verify_code = sec_trust_result_type_as_int
+        raise err
+
+
+def _verify_peercerts_impl_macos_10_14(
+    ssl_context: ssl.SSLContext, sec_trust_ref: typing.Any
+) -> None:
+    """Verify using 'SecTrustEvaluateWithError' API for macOS 10.14+."""
+    cf_error = CoreFoundation.CFErrorRef()
+    sec_trust_eval_result = Security.SecTrustEvaluateWithError(
+        sec_trust_ref, ctypes.byref(cf_error)
+    )
+    # sec_trust_eval_result is a bool (0 or 1)
+    # where 1 means that the certs are trusted.
+    if sec_trust_eval_result == 1:
+        is_trusted = True
+    elif sec_trust_eval_result == 0:
+        is_trusted = False
+    else:
+        raise ssl.SSLError(
+            f"Unknown result from Security.SecTrustEvaluateWithError: {sec_trust_eval_result!r}"
+        )
+
+    cf_error_code = 0
+    if not is_trusted:
+        cf_error_code = CoreFoundation.CFErrorGetCode(cf_error)
+
+        # If the error is a known failure that we're
+        # explicitly okay with from SSLContext configuration
+        # we can set is_trusted accordingly.
+        if ssl_context.verify_mode != ssl.CERT_REQUIRED and (
+            cf_error_code == CFConst.errSecNotTrusted
+            or cf_error_code == CFConst.errSecCertificateExpired
+        ):
+            is_trusted = True
+
+    # If we're still not trusted then we start to
+    # construct and raise the SSLCertVerificationError.
+    if not is_trusted:
+        cf_error_string_ref = None
+        try:
+            cf_error_string_ref = CoreFoundation.CFErrorCopyDescription(cf_error)
+
+            # Can this ever return 'None' if there's a CFError?
+            cf_error_message = (
+                _cf_string_ref_to_str(cf_error_string_ref)
+                or "Certificate verification failed"
+            )
+
+            # TODO: Not sure if we need the SecTrustResultType for anything?
+            # We only care whether or not it's a success or failure for now.
+            sec_trust_result_type = Security.SecTrustResultType()
+            Security.SecTrustGetTrustResult(
+                sec_trust_ref, ctypes.byref(sec_trust_result_type)
+            )
+
+            err = ssl.SSLCertVerificationError(cf_error_message)
+            err.verify_message = cf_error_message
+            err.verify_code = cf_error_code
+            raise err
+        finally:
+            if cf_error_string_ref:
+                CoreFoundation.CFRelease(cf_error_string_ref)

openflamingo/lib/python3.10/site-packages/pip/_vendor/truststore/_openssl.py

@@ -0,0 +1,66 @@
+import contextlib
+import os
+import re
+import ssl
+import typing
+
+# candidates based on https://github.com/tiran/certifi-system-store by Christian Heimes
+_CA_FILE_CANDIDATES = [
+    # Alpine, Arch, Fedora 34+, OpenWRT, RHEL 9+, BSD
+    "/etc/ssl/cert.pem",
+    # Fedora <= 34, RHEL <= 9, CentOS <= 9
+    "/etc/pki/tls/cert.pem",
+    # Debian, Ubuntu (requires ca-certificates)
+    "/etc/ssl/certs/ca-certificates.crt",
+    # SUSE
+    "/etc/ssl/ca-bundle.pem",
+]
+
+_HASHED_CERT_FILENAME_RE = re.compile(r"^[0-9a-fA-F]{8}\.[0-9]$")
+
+
+@contextlib.contextmanager
+def _configure_context(ctx: ssl.SSLContext) -> typing.Iterator[None]:
+    # First, check whether the default locations from OpenSSL
+    # seem like they will give us a usable set of CA certs.
+    # ssl.get_default_verify_paths already takes care of:
+    # - getting cafile from either the SSL_CERT_FILE env var
+    #   or the path configured when OpenSSL was compiled,
+    #   and verifying that that path exists
+    # - getting capath from either the SSL_CERT_DIR env var
+    #   or the path configured when OpenSSL was compiled,
+    #   and verifying that that path exists
+    # In addition we'll check whether capath appears to contain certs.
+    defaults = ssl.get_default_verify_paths()
+    if defaults.cafile or (defaults.capath and _capath_contains_certs(defaults.capath)):
+        ctx.set_default_verify_paths()
+    else:
+        # cafile from OpenSSL doesn't exist
+        # and capath from OpenSSL doesn't contain certs.
+        # Let's search other common locations instead.
+        for cafile in _CA_FILE_CANDIDATES:
+            if os.path.isfile(cafile):
+                ctx.load_verify_locations(cafile=cafile)
+                break
+
+    yield
+
+
+def _capath_contains_certs(capath: str) -> bool:
+    """Check whether capath exists and contains certs in the expected format."""
+    if not os.path.isdir(capath):
+        return False
+    for name in os.listdir(capath):
+        if _HASHED_CERT_FILENAME_RE.match(name):
+            return True
+    return False
+
+
+def _verify_peercerts_impl(
+    ssl_context: ssl.SSLContext,
+    cert_chain: list[bytes],
+    server_hostname: str | None = None,
+) -> None:
+    # This is a no-op because we've enabled SSLContext's built-in
+    # verification via verify_mode=CERT_REQUIRED, and don't need to repeat it.
+    pass

openflamingo/lib/python3.10/site-packages/pip/_vendor/truststore/_ssl_constants.py

@@ -0,0 +1,31 @@
+import ssl
+import sys
+import typing
+
+# Hold on to the original class so we can create it consistently
+# even if we inject our own SSLContext into the ssl module.
+_original_SSLContext = ssl.SSLContext
+_original_super_SSLContext = super(_original_SSLContext, _original_SSLContext)
+
+# CPython is known to be good, but non-CPython implementations
+# may implement SSLContext differently so to be safe we don't
+# subclass the SSLContext.
+
+# This is returned by truststore.SSLContext.__class__()
+_truststore_SSLContext_dunder_class: typing.Optional[type]
+
+# This value is the superclass of truststore.SSLContext.
+_truststore_SSLContext_super_class: type
+
+if sys.implementation.name == "cpython":
+    _truststore_SSLContext_super_class = _original_SSLContext
+    _truststore_SSLContext_dunder_class = None
+else:
+    _truststore_SSLContext_super_class = object
+    _truststore_SSLContext_dunder_class = _original_SSLContext
+
+
+def _set_ssl_context_verify_mode(
+    ssl_context: ssl.SSLContext, verify_mode: ssl.VerifyMode
+) -> None:
+    _original_super_SSLContext.verify_mode.__set__(ssl_context, verify_mode)  # type: ignore[attr-defined]

openflamingo/lib/python3.10/site-packages/pip/_vendor/truststore/_windows.py

@@ -0,0 +1,567 @@
+import contextlib
+import ssl
+import typing
+from ctypes import WinDLL  # type: ignore
+from ctypes import WinError  # type: ignore
+from ctypes import (
+    POINTER,
+    Structure,
+    c_char_p,
+    c_ulong,
+    c_void_p,
+    c_wchar_p,
+    cast,
+    create_unicode_buffer,
+    pointer,
+    sizeof,
+)
+from ctypes.wintypes import (
+    BOOL,
+    DWORD,
+    HANDLE,
+    LONG,
+    LPCSTR,
+    LPCVOID,
+    LPCWSTR,
+    LPFILETIME,
+    LPSTR,
+    LPWSTR,
+)
+from typing import TYPE_CHECKING, Any
+
+from ._ssl_constants import _set_ssl_context_verify_mode
+
+HCERTCHAINENGINE = HANDLE
+HCERTSTORE = HANDLE
+HCRYPTPROV_LEGACY = HANDLE
+
+
+class CERT_CONTEXT(Structure):
+    _fields_ = (
+        ("dwCertEncodingType", DWORD),
+        ("pbCertEncoded", c_void_p),
+        ("cbCertEncoded", DWORD),
+        ("pCertInfo", c_void_p),
+        ("hCertStore", HCERTSTORE),
+    )
+
+
+PCERT_CONTEXT = POINTER(CERT_CONTEXT)
+PCCERT_CONTEXT = POINTER(PCERT_CONTEXT)
+
+
+class CERT_ENHKEY_USAGE(Structure):
+    _fields_ = (
+        ("cUsageIdentifier", DWORD),
+        ("rgpszUsageIdentifier", POINTER(LPSTR)),
+    )
+
+
+PCERT_ENHKEY_USAGE = POINTER(CERT_ENHKEY_USAGE)
+
+
+class CERT_USAGE_MATCH(Structure):
+    _fields_ = (
+        ("dwType", DWORD),
+        ("Usage", CERT_ENHKEY_USAGE),
+    )
+
+
+class CERT_CHAIN_PARA(Structure):
+    _fields_ = (
+        ("cbSize", DWORD),
+        ("RequestedUsage", CERT_USAGE_MATCH),
+        ("RequestedIssuancePolicy", CERT_USAGE_MATCH),
+        ("dwUrlRetrievalTimeout", DWORD),
+        ("fCheckRevocationFreshnessTime", BOOL),
+        ("dwRevocationFreshnessTime", DWORD),
+        ("pftCacheResync", LPFILETIME),
+        ("pStrongSignPara", c_void_p),
+        ("dwStrongSignFlags", DWORD),
+    )
+
+
+if TYPE_CHECKING:
+    PCERT_CHAIN_PARA = pointer[CERT_CHAIN_PARA]  # type: ignore[misc]
+else:
+    PCERT_CHAIN_PARA = POINTER(CERT_CHAIN_PARA)
+
+
+class CERT_TRUST_STATUS(Structure):
+    _fields_ = (
+        ("dwErrorStatus", DWORD),
+        ("dwInfoStatus", DWORD),
+    )
+
+
+class CERT_CHAIN_ELEMENT(Structure):
+    _fields_ = (
+        ("cbSize", DWORD),
+        ("pCertContext", PCERT_CONTEXT),
+        ("TrustStatus", CERT_TRUST_STATUS),
+        ("pRevocationInfo", c_void_p),
+        ("pIssuanceUsage", PCERT_ENHKEY_USAGE),
+        ("pApplicationUsage", PCERT_ENHKEY_USAGE),
+        ("pwszExtendedErrorInfo", LPCWSTR),
+    )
+
+
+PCERT_CHAIN_ELEMENT = POINTER(CERT_CHAIN_ELEMENT)
+
+
+class CERT_SIMPLE_CHAIN(Structure):
+    _fields_ = (
+        ("cbSize", DWORD),
+        ("TrustStatus", CERT_TRUST_STATUS),
+        ("cElement", DWORD),
+        ("rgpElement", POINTER(PCERT_CHAIN_ELEMENT)),
+        ("pTrustListInfo", c_void_p),
+        ("fHasRevocationFreshnessTime", BOOL),
+        ("dwRevocationFreshnessTime", DWORD),
+    )
+
+
+PCERT_SIMPLE_CHAIN = POINTER(CERT_SIMPLE_CHAIN)
+
+
+class CERT_CHAIN_CONTEXT(Structure):
+    _fields_ = (
+        ("cbSize", DWORD),
+        ("TrustStatus", CERT_TRUST_STATUS),
+        ("cChain", DWORD),
+        ("rgpChain", POINTER(PCERT_SIMPLE_CHAIN)),
+        ("cLowerQualityChainContext", DWORD),
+        ("rgpLowerQualityChainContext", c_void_p),
+        ("fHasRevocationFreshnessTime", BOOL),
+        ("dwRevocationFreshnessTime", DWORD),
+    )
+
+
+PCERT_CHAIN_CONTEXT = POINTER(CERT_CHAIN_CONTEXT)
+PCCERT_CHAIN_CONTEXT = POINTER(PCERT_CHAIN_CONTEXT)
+
+
+class SSL_EXTRA_CERT_CHAIN_POLICY_PARA(Structure):
+    _fields_ = (
+        ("cbSize", DWORD),
+        ("dwAuthType", DWORD),
+        ("fdwChecks", DWORD),
+        ("pwszServerName", LPCWSTR),
+    )
+
+
+class CERT_CHAIN_POLICY_PARA(Structure):
+    _fields_ = (
+        ("cbSize", DWORD),
+        ("dwFlags", DWORD),
+        ("pvExtraPolicyPara", c_void_p),
+    )
+
+
+PCERT_CHAIN_POLICY_PARA = POINTER(CERT_CHAIN_POLICY_PARA)
+
+
+class CERT_CHAIN_POLICY_STATUS(Structure):
+    _fields_ = (
+        ("cbSize", DWORD),
+        ("dwError", DWORD),
+        ("lChainIndex", LONG),
+        ("lElementIndex", LONG),
+        ("pvExtraPolicyStatus", c_void_p),
+    )
+
+
+PCERT_CHAIN_POLICY_STATUS = POINTER(CERT_CHAIN_POLICY_STATUS)
+
+
+class CERT_CHAIN_ENGINE_CONFIG(Structure):
+    _fields_ = (
+        ("cbSize", DWORD),
+        ("hRestrictedRoot", HCERTSTORE),
+        ("hRestrictedTrust", HCERTSTORE),
+        ("hRestrictedOther", HCERTSTORE),
+        ("cAdditionalStore", DWORD),
+        ("rghAdditionalStore", c_void_p),
+        ("dwFlags", DWORD),
+        ("dwUrlRetrievalTimeout", DWORD),
+        ("MaximumCachedCertificates", DWORD),
+        ("CycleDetectionModulus", DWORD),
+        ("hExclusiveRoot", HCERTSTORE),
+        ("hExclusiveTrustedPeople", HCERTSTORE),
+        ("dwExclusiveFlags", DWORD),
+    )
+
+
+PCERT_CHAIN_ENGINE_CONFIG = POINTER(CERT_CHAIN_ENGINE_CONFIG)
+PHCERTCHAINENGINE = POINTER(HCERTCHAINENGINE)
+
+X509_ASN_ENCODING = 0x00000001
+PKCS_7_ASN_ENCODING = 0x00010000
+CERT_STORE_PROV_MEMORY = b"Memory"
+CERT_STORE_ADD_USE_EXISTING = 2
+USAGE_MATCH_TYPE_OR = 1
+OID_PKIX_KP_SERVER_AUTH = c_char_p(b"1.3.6.1.5.5.7.3.1")
+CERT_CHAIN_REVOCATION_CHECK_END_CERT = 0x10000000
+CERT_CHAIN_REVOCATION_CHECK_CHAIN = 0x20000000
+CERT_CHAIN_POLICY_IGNORE_ALL_NOT_TIME_VALID_FLAGS = 0x00000007
+CERT_CHAIN_POLICY_IGNORE_INVALID_BASIC_CONSTRAINTS_FLAG = 0x00000008
+CERT_CHAIN_POLICY_ALLOW_UNKNOWN_CA_FLAG = 0x00000010
+CERT_CHAIN_POLICY_IGNORE_INVALID_NAME_FLAG = 0x00000040
+CERT_CHAIN_POLICY_IGNORE_WRONG_USAGE_FLAG = 0x00000020
+CERT_CHAIN_POLICY_IGNORE_INVALID_POLICY_FLAG = 0x00000080
+CERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGS = 0x00000F00
+CERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAG = 0x00008000
+CERT_CHAIN_POLICY_TRUST_TESTROOT_FLAG = 0x00004000
+SECURITY_FLAG_IGNORE_CERT_CN_INVALID = 0x00001000
+AUTHTYPE_SERVER = 2
+CERT_CHAIN_POLICY_SSL = 4
+FORMAT_MESSAGE_FROM_SYSTEM = 0x00001000
+FORMAT_MESSAGE_IGNORE_INSERTS = 0x00000200
+
+# Flags to set for SSLContext.verify_mode=CERT_NONE
+CERT_CHAIN_POLICY_VERIFY_MODE_NONE_FLAGS = (
+    CERT_CHAIN_POLICY_IGNORE_ALL_NOT_TIME_VALID_FLAGS
+    | CERT_CHAIN_POLICY_IGNORE_INVALID_BASIC_CONSTRAINTS_FLAG
+    | CERT_CHAIN_POLICY_ALLOW_UNKNOWN_CA_FLAG
+    | CERT_CHAIN_POLICY_IGNORE_INVALID_NAME_FLAG
+    | CERT_CHAIN_POLICY_IGNORE_WRONG_USAGE_FLAG
+    | CERT_CHAIN_POLICY_IGNORE_INVALID_POLICY_FLAG
+    | CERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGS
+    | CERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAG
+    | CERT_CHAIN_POLICY_TRUST_TESTROOT_FLAG
+)
+
+wincrypt = WinDLL("crypt32.dll")
+kernel32 = WinDLL("kernel32.dll")
+
+
+def _handle_win_error(result: bool, _: Any, args: Any) -> Any:
+    if not result:
+        # Note, actually raises OSError after calling GetLastError and FormatMessage
+        raise WinError()
+    return args
+
+
+CertCreateCertificateChainEngine = wincrypt.CertCreateCertificateChainEngine
+CertCreateCertificateChainEngine.argtypes = (
+    PCERT_CHAIN_ENGINE_CONFIG,
+    PHCERTCHAINENGINE,
+)
+CertCreateCertificateChainEngine.errcheck = _handle_win_error
+
+CertOpenStore = wincrypt.CertOpenStore
+CertOpenStore.argtypes = (LPCSTR, DWORD, HCRYPTPROV_LEGACY, DWORD, c_void_p)
+CertOpenStore.restype = HCERTSTORE
+CertOpenStore.errcheck = _handle_win_error
+
+CertAddEncodedCertificateToStore = wincrypt.CertAddEncodedCertificateToStore
+CertAddEncodedCertificateToStore.argtypes = (
+    HCERTSTORE,
+    DWORD,
+    c_char_p,
+    DWORD,
+    DWORD,
+    PCCERT_CONTEXT,
+)
+CertAddEncodedCertificateToStore.restype = BOOL
+
+CertCreateCertificateContext = wincrypt.CertCreateCertificateContext
+CertCreateCertificateContext.argtypes = (DWORD, c_char_p, DWORD)
+CertCreateCertificateContext.restype = PCERT_CONTEXT
+CertCreateCertificateContext.errcheck = _handle_win_error
+
+CertGetCertificateChain = wincrypt.CertGetCertificateChain
+CertGetCertificateChain.argtypes = (
+    HCERTCHAINENGINE,
+    PCERT_CONTEXT,
+    LPFILETIME,
+    HCERTSTORE,
+    PCERT_CHAIN_PARA,
+    DWORD,
+    c_void_p,
+    PCCERT_CHAIN_CONTEXT,
+)
+CertGetCertificateChain.restype = BOOL
+CertGetCertificateChain.errcheck = _handle_win_error
+
+CertVerifyCertificateChainPolicy = wincrypt.CertVerifyCertificateChainPolicy
+CertVerifyCertificateChainPolicy.argtypes = (
+    c_ulong,
+    PCERT_CHAIN_CONTEXT,
+    PCERT_CHAIN_POLICY_PARA,
+    PCERT_CHAIN_POLICY_STATUS,
+)
+CertVerifyCertificateChainPolicy.restype = BOOL
+
+CertCloseStore = wincrypt.CertCloseStore
+CertCloseStore.argtypes = (HCERTSTORE, DWORD)
+CertCloseStore.restype = BOOL
+CertCloseStore.errcheck = _handle_win_error
+
+CertFreeCertificateChain = wincrypt.CertFreeCertificateChain
+CertFreeCertificateChain.argtypes = (PCERT_CHAIN_CONTEXT,)
+
+CertFreeCertificateContext = wincrypt.CertFreeCertificateContext
+CertFreeCertificateContext.argtypes = (PCERT_CONTEXT,)
+
+CertFreeCertificateChainEngine = wincrypt.CertFreeCertificateChainEngine
+CertFreeCertificateChainEngine.argtypes = (HCERTCHAINENGINE,)
+
+FormatMessageW = kernel32.FormatMessageW
+FormatMessageW.argtypes = (
+    DWORD,
+    LPCVOID,
+    DWORD,
+    DWORD,
+    LPWSTR,
+    DWORD,
+    c_void_p,
+)
+FormatMessageW.restype = DWORD
+
+
+def _verify_peercerts_impl(
+    ssl_context: ssl.SSLContext,
+    cert_chain: list[bytes],
+    server_hostname: str | None = None,
+) -> None:
+    """Verify the cert_chain from the server using Windows APIs."""
+
+    # If the peer didn't send any certificates then
+    # we can't do verification. Raise an error.
+    if not cert_chain:
+        raise ssl.SSLCertVerificationError("Peer sent no certificates to verify")
+
+    pCertContext = None
+    hIntermediateCertStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, None, 0, None)
+    try:
+        # Add intermediate certs to an in-memory cert store
+        for cert_bytes in cert_chain[1:]:
+            CertAddEncodedCertificateToStore(
+                hIntermediateCertStore,
+                X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
+                cert_bytes,
+                len(cert_bytes),
+                CERT_STORE_ADD_USE_EXISTING,
+                None,
+            )
+
+        # Cert context for leaf cert
+        leaf_cert = cert_chain[0]
+        pCertContext = CertCreateCertificateContext(
+            X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, leaf_cert, len(leaf_cert)
+        )
+
+        # Chain params to match certs for serverAuth extended usage
+        cert_enhkey_usage = CERT_ENHKEY_USAGE()
+        cert_enhkey_usage.cUsageIdentifier = 1
+        cert_enhkey_usage.rgpszUsageIdentifier = (c_char_p * 1)(OID_PKIX_KP_SERVER_AUTH)
+        cert_usage_match = CERT_USAGE_MATCH()
+        cert_usage_match.Usage = cert_enhkey_usage
+        chain_params = CERT_CHAIN_PARA()
+        chain_params.RequestedUsage = cert_usage_match
+        chain_params.cbSize = sizeof(chain_params)
+        pChainPara = pointer(chain_params)
+
+        if ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_CHAIN:
+            chain_flags = CERT_CHAIN_REVOCATION_CHECK_CHAIN
+        elif ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_LEAF:
+            chain_flags = CERT_CHAIN_REVOCATION_CHECK_END_CERT
+        else:
+            chain_flags = 0
+
+        try:
+            # First attempt to verify using the default Windows system trust roots
+            # (default chain engine).
+            _get_and_verify_cert_chain(
+                ssl_context,
+                None,
+                hIntermediateCertStore,
+                pCertContext,
+                pChainPara,
+                server_hostname,
+                chain_flags=chain_flags,
+            )
+        except ssl.SSLCertVerificationError as e:
+            # If that fails but custom CA certs have been added
+            # to the SSLContext using load_verify_locations,
+            # try verifying using a custom chain engine
+            # that trusts the custom CA certs.
+            custom_ca_certs: list[bytes] | None = ssl_context.get_ca_certs(
+                binary_form=True
+            )
+            if custom_ca_certs:
+                try:
+                    _verify_using_custom_ca_certs(
+                        ssl_context,
+                        custom_ca_certs,
+                        hIntermediateCertStore,
+                        pCertContext,
+                        pChainPara,
+                        server_hostname,
+                        chain_flags=chain_flags,
+                    )
+                # Raise the original error, not the new error.
+                except ssl.SSLCertVerificationError:
+                    raise e from None
+            else:
+                raise
+    finally:
+        CertCloseStore(hIntermediateCertStore, 0)
+        if pCertContext:
+            CertFreeCertificateContext(pCertContext)
+
+
+def _get_and_verify_cert_chain(
+    ssl_context: ssl.SSLContext,
+    hChainEngine: HCERTCHAINENGINE | None,
+    hIntermediateCertStore: HCERTSTORE,
+    pPeerCertContext: c_void_p,
+    pChainPara: PCERT_CHAIN_PARA,  # type: ignore[valid-type]
+    server_hostname: str | None,
+    chain_flags: int,
+) -> None:
+    ppChainContext = None
+    try:
+        # Get cert chain
+        ppChainContext = pointer(PCERT_CHAIN_CONTEXT())
+        CertGetCertificateChain(
+            hChainEngine,  # chain engine
+            pPeerCertContext,  # leaf cert context
+            None,  # current system time
+            hIntermediateCertStore,  # additional in-memory cert store
+            pChainPara,  # chain-building parameters
+            chain_flags,
+            None,  # reserved
+            ppChainContext,  # the resulting chain context
+        )
+        pChainContext = ppChainContext.contents
+
+        # Verify cert chain
+        ssl_extra_cert_chain_policy_para = SSL_EXTRA_CERT_CHAIN_POLICY_PARA()
+        ssl_extra_cert_chain_policy_para.cbSize = sizeof(
+            ssl_extra_cert_chain_policy_para
+        )
+        ssl_extra_cert_chain_policy_para.dwAuthType = AUTHTYPE_SERVER
+        ssl_extra_cert_chain_policy_para.fdwChecks = 0
+        if ssl_context.check_hostname is False:
+            ssl_extra_cert_chain_policy_para.fdwChecks = (
+                SECURITY_FLAG_IGNORE_CERT_CN_INVALID
+            )
+        if server_hostname:
+            ssl_extra_cert_chain_policy_para.pwszServerName = c_wchar_p(server_hostname)
+
+        chain_policy = CERT_CHAIN_POLICY_PARA()
+        chain_policy.pvExtraPolicyPara = cast(
+            pointer(ssl_extra_cert_chain_policy_para), c_void_p
+        )
+        if ssl_context.verify_mode == ssl.CERT_NONE:
+            chain_policy.dwFlags |= CERT_CHAIN_POLICY_VERIFY_MODE_NONE_FLAGS
+        chain_policy.cbSize = sizeof(chain_policy)
+
+        pPolicyPara = pointer(chain_policy)
+        policy_status = CERT_CHAIN_POLICY_STATUS()
+        policy_status.cbSize = sizeof(policy_status)
+        pPolicyStatus = pointer(policy_status)
+        CertVerifyCertificateChainPolicy(
+            CERT_CHAIN_POLICY_SSL,
+            pChainContext,
+            pPolicyPara,
+            pPolicyStatus,
+        )
+
+        # Check status
+        error_code = policy_status.dwError
+        if error_code:
+            # Try getting a human readable message for an error code.
+            error_message_buf = create_unicode_buffer(1024)
+            error_message_chars = FormatMessageW(
+                FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+                None,
+                error_code,
+                0,
+                error_message_buf,
+                sizeof(error_message_buf),
+                None,
+            )
+
+            # See if we received a message for the error,
+            # otherwise we use a generic error with the
+            # error code and hope that it's search-able.
+            if error_message_chars <= 0:
+                error_message = f"Certificate chain policy error {error_code:#x} [{policy_status.lElementIndex}]"
+            else:
+                error_message = error_message_buf.value.strip()
+
+            err = ssl.SSLCertVerificationError(error_message)
+            err.verify_message = error_message
+            err.verify_code = error_code
+            raise err from None
+    finally:
+        if ppChainContext:
+            CertFreeCertificateChain(ppChainContext.contents)
+
+
+def _verify_using_custom_ca_certs(
+    ssl_context: ssl.SSLContext,
+    custom_ca_certs: list[bytes],
+    hIntermediateCertStore: HCERTSTORE,
+    pPeerCertContext: c_void_p,
+    pChainPara: PCERT_CHAIN_PARA,  # type: ignore[valid-type]
+    server_hostname: str | None,
+    chain_flags: int,
+) -> None:
+    hChainEngine = None
+    hRootCertStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, None, 0, None)
+    try:
+        # Add custom CA certs to an in-memory cert store
+        for cert_bytes in custom_ca_certs:
+            CertAddEncodedCertificateToStore(
+                hRootCertStore,
+                X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
+                cert_bytes,
+                len(cert_bytes),
+                CERT_STORE_ADD_USE_EXISTING,
+                None,
+            )
+
+        # Create a custom cert chain engine which exclusively trusts
+        # certs from our hRootCertStore
+        cert_chain_engine_config = CERT_CHAIN_ENGINE_CONFIG()
+        cert_chain_engine_config.cbSize = sizeof(cert_chain_engine_config)
+        cert_chain_engine_config.hExclusiveRoot = hRootCertStore
+        pConfig = pointer(cert_chain_engine_config)
+        phChainEngine = pointer(HCERTCHAINENGINE())
+        CertCreateCertificateChainEngine(
+            pConfig,
+            phChainEngine,
+        )
+        hChainEngine = phChainEngine.contents
+
+        # Get and verify a cert chain using the custom chain engine
+        _get_and_verify_cert_chain(
+            ssl_context,
+            hChainEngine,
+            hIntermediateCertStore,
+            pPeerCertContext,
+            pChainPara,
+            server_hostname,
+            chain_flags,
+        )
+    finally:
+        if hChainEngine:
+            CertFreeCertificateChainEngine(hChainEngine)
+        CertCloseStore(hRootCertStore, 0)
+
+
+@contextlib.contextmanager
+def _configure_context(ctx: ssl.SSLContext) -> typing.Iterator[None]:
+    check_hostname = ctx.check_hostname
+    verify_mode = ctx.verify_mode
+    ctx.check_hostname = False
+    _set_ssl_context_verify_mode(ctx, ssl.CERT_NONE)
+    try:
+        yield
+    finally:
+        ctx.check_hostname = check_hostname
+        _set_ssl_context_verify_mode(ctx, verify_mode)