diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_bsr.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_bsr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fb75f68b93132f00d993d962ffead31f8e2c886f
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_bsr.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_compressed.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_compressed.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..044b7c8db9d83629341c29be599fe1019712496d
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_compressed.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_construct.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_construct.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2aaed634361f314e1dc53fa9cc1128622d0df8b8
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_construct.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_coo.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_coo.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..56db6a882afe073ebfec11b48b85ed3b0578a86a
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_coo.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_csc.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_csc.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0a3f166db868b8c48a98abb2dbec06be52077f14
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_csc.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_data.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_data.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e04427d1ea32be03786b703f35fdc06717bcd37
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_data.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_dia.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_dia.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..69e8b9ea22900b80bb50787e257d9b5ef92b2c0f
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_dia.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_dok.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_dok.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..48314b582bd7242ec9f40555ba1de617626321b4
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_dok.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_extract.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_extract.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..74e2fc74908068efd43696c5db7167642d6b9f78
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_extract.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_index.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_index.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..88da40fc54d8b678776aa59ed66d882c2908c241
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_index.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_lil.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_lil.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fca7fefbe8cfb9b3c657fa03b7b30f7d3072979c
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_lil.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_matrix.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_matrix.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1abf8f0e30dc1a12fff0d0f1d40c169b933f3fd0
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_matrix.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_matrix_io.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_matrix_io.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8bd748777cdb4ddc74c325f3315abe0fa306a90e
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_matrix_io.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_spfuncs.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_spfuncs.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..72a5bb5f9b38fe7bc43c79bf38b6567585d8b3ed
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_spfuncs.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_sputils.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_sputils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8e33592762aa0dd3a7688f22e2004490198e945a
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/_sputils.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/base.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/base.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f685fe0f875f7216aaf5287637bf9f89d70c5c2c
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/base.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/bsr.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/bsr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6fb1323193e0237e5c40f9b9fa37c71e04f53f63
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/bsr.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/compressed.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/compressed.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8b5f7fc5317cd4e4147b9da25845d7fba4f16c57
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/compressed.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/construct.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/construct.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d885192f45c5aaa67f968a0a8d25f53d12aad108
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/construct.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/coo.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/coo.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5eb5f3322fad59b4591cfeb957771602dc75ae40
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/coo.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/csc.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/csc.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8f52f356766b6f596cfe666524ba91c3f2c25f4f
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/csc.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/csr.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/csr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..953d0cfbf0a88c8d31d2f5d424247d3405f90341
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/csr.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/data.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/data.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2b5f62ca3c69b9ad81dc3e1083962826cc0156ab
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/data.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/dia.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/dia.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..643c78c6ee72bc4b6897204800db0c4870991b5e
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/dia.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/dok.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/dok.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..849859bb95b9210388be57b39d3b62bdb71198ad
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/dok.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/lil.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/lil.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a5a60355e9d88c654c2ee940a6e43eaed839724b
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/lil.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/sparsetools.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/sparsetools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0c18818efe1dfa57af8c810f49ac6395ad03911f
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/sparsetools.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/sputils.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/sputils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4707e115721d457ff6eff2c925d2988514a3c115
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/__pycache__/sputils.cpython-310.pyc differ
diff --git a/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/csgraph/__pycache__/__init__.cpython-310.pyc b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/csgraph/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e9167dc873e0694c8090c710c3fc356b681c575a
Binary files /dev/null and b/mantis_evalkit/lib/python3.10/site-packages/scipy/sparse/csgraph/__pycache__/__init__.cpython-310.pyc differ
diff --git a/moondream/lib/python3.10/site-packages/matplotlib/__init__.py b/moondream/lib/python3.10/site-packages/matplotlib/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f964e0b34dea11f572136a3bb6e3d9968ebe754
--- /dev/null
+++ b/moondream/lib/python3.10/site-packages/matplotlib/__init__.py
@@ -0,0 +1,1576 @@
+"""
+An object-oriented plotting library.
+
+A procedural interface is provided by the companion pyplot module,
+which may be imported directly, e.g.::
+
+ import matplotlib.pyplot as plt
+
+or using ipython::
+
+ ipython
+
+at your terminal, followed by::
+
+ In [1]: %matplotlib
+ In [2]: import matplotlib.pyplot as plt
+
+at the ipython shell prompt.
+
+For the most part, direct use of the explicit object-oriented library is
+encouraged when programming; the implicit pyplot interface is primarily for
+working interactively. The exceptions to this suggestion are the pyplot
+functions `.pyplot.figure`, `.pyplot.subplot`, `.pyplot.subplots`, and
+`.pyplot.savefig`, which can greatly simplify scripting. See
+:ref:`api_interfaces` for an explanation of the tradeoffs between the implicit
+and explicit interfaces.
+
+Modules include:
+
+:mod:`matplotlib.axes`
+ The `~.axes.Axes` class. Most pyplot functions are wrappers for
+ `~.axes.Axes` methods. The axes module is the highest level of OO
+ access to the library.
+
+:mod:`matplotlib.figure`
+ The `.Figure` class.
+
+:mod:`matplotlib.artist`
+ The `.Artist` base class for all classes that draw things.
+
+:mod:`matplotlib.lines`
+ The `.Line2D` class for drawing lines and markers.
+
+:mod:`matplotlib.patches`
+ Classes for drawing polygons.
+
+:mod:`matplotlib.text`
+ The `.Text` and `.Annotation` classes.
+
+:mod:`matplotlib.image`
+ The `.AxesImage` and `.FigureImage` classes.
+
+:mod:`matplotlib.collections`
+ Classes for efficient drawing of groups of lines or polygons.
+
+:mod:`matplotlib.colors`
+ Color specifications and making colormaps.
+
+:mod:`matplotlib.cm`
+ Colormaps, and the `.ScalarMappable` mixin class for providing color
+ mapping functionality to other classes.
+
+:mod:`matplotlib.ticker`
+ Calculation of tick mark locations and formatting of tick labels.
+
+:mod:`matplotlib.backends`
+ A subpackage with modules for various GUI libraries and output formats.
+
+The base matplotlib namespace includes:
+
+`~matplotlib.rcParams`
+ Default configuration settings; their defaults may be overridden using
+ a :file:`matplotlibrc` file.
+
+`~matplotlib.use`
+ Setting the Matplotlib backend. This should be called before any
+ figure is created, because it is not possible to switch between
+ different GUI backends after that.
+
+The following environment variables can be used to customize the behavior:
+
+:envvar:`MPLBACKEND`
+ This optional variable can be set to choose the Matplotlib backend. See
+ :ref:`what-is-a-backend`.
+
+:envvar:`MPLCONFIGDIR`
+ This is the directory used to store user customizations to
+ Matplotlib, as well as some caches to improve performance. If
+ :envvar:`MPLCONFIGDIR` is not defined, :file:`{HOME}/.config/matplotlib`
+ and :file:`{HOME}/.cache/matplotlib` are used on Linux, and
+ :file:`{HOME}/.matplotlib` on other platforms, if they are
+ writable. Otherwise, the Python standard library's `tempfile.gettempdir`
+ is used to find a base directory in which the :file:`matplotlib`
+ subdirectory is created.
+
+Matplotlib was initially written by John D. Hunter (1968-2012) and is now
+developed and maintained by a host of others.
+
+Occasionally the internal documentation (python docstrings) will refer
+to MATLAB®, a registered trademark of The MathWorks, Inc.
+
+"""
+
+__all__ = [
+ "__bibtex__",
+ "__version__",
+ "__version_info__",
+ "set_loglevel",
+ "ExecutableNotFoundError",
+ "get_configdir",
+ "get_cachedir",
+ "get_data_path",
+ "matplotlib_fname",
+ "MatplotlibDeprecationWarning",
+ "RcParams",
+ "rc_params",
+ "rc_params_from_file",
+ "rcParamsDefault",
+ "rcParams",
+ "rcParamsOrig",
+ "defaultParams",
+ "rc",
+ "rcdefaults",
+ "rc_file_defaults",
+ "rc_file",
+ "rc_context",
+ "use",
+ "get_backend",
+ "interactive",
+ "is_interactive",
+ "colormaps",
+ "multivar_colormaps",
+ "bivar_colormaps",
+ "color_sequences",
+]
+
+
+import atexit
+from collections import namedtuple
+from collections.abc import MutableMapping
+import contextlib
+import functools
+import importlib
+import inspect
+from inspect import Parameter
+import locale
+import logging
+import os
+from pathlib import Path
+import pprint
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+
+from packaging.version import parse as parse_version
+
+# cbook must import matplotlib only within function
+# definitions, so it is safe to import from it here.
+from . import _api, _version, cbook, _docstring, rcsetup
+from matplotlib._api import MatplotlibDeprecationWarning
+from matplotlib.rcsetup import cycler # noqa: F401
+
+
+_log = logging.getLogger(__name__)
+
+__bibtex__ = r"""@Article{Hunter:2007,
+ Author = {Hunter, J. D.},
+ Title = {Matplotlib: A 2D graphics environment},
+ Journal = {Computing in Science \& Engineering},
+ Volume = {9},
+ Number = {3},
+ Pages = {90--95},
+ abstract = {Matplotlib is a 2D graphics package used for Python
+ for application development, interactive scripting, and
+ publication-quality image generation across user
+ interfaces and operating systems.},
+ publisher = {IEEE COMPUTER SOC},
+ year = 2007
+}"""
+
+# modelled after sys.version_info
+_VersionInfo = namedtuple('_VersionInfo',
+ 'major, minor, micro, releaselevel, serial')
+
+
+def _parse_to_version_info(version_str):
+ """
+ Parse a version string to a namedtuple analogous to sys.version_info.
+
+ See:
+ https://packaging.pypa.io/en/latest/version.html#packaging.version.parse
+ https://docs.python.org/3/library/sys.html#sys.version_info
+ """
+ v = parse_version(version_str)
+ if v.pre is None and v.post is None and v.dev is None:
+ return _VersionInfo(v.major, v.minor, v.micro, 'final', 0)
+ elif v.dev is not None:
+ return _VersionInfo(v.major, v.minor, v.micro, 'alpha', v.dev)
+ elif v.pre is not None:
+ releaselevel = {
+ 'a': 'alpha',
+ 'b': 'beta',
+ 'rc': 'candidate'}.get(v.pre[0], 'alpha')
+ return _VersionInfo(v.major, v.minor, v.micro, releaselevel, v.pre[1])
+ else:
+ # fallback for v.post: guess-next-dev scheme from setuptools_scm
+ return _VersionInfo(v.major, v.minor, v.micro + 1, 'alpha', v.post)
+
+
+def _get_version():
+ """Return the version string used for __version__."""
+ # Only shell out to a git subprocess if really needed, i.e. when we are in
+ # a matplotlib git repo but not in a shallow clone, such as those used by
+ # CI, as the latter would trigger a warning from setuptools_scm.
+ root = Path(__file__).resolve().parents[2]
+ if ((root / ".matplotlib-repo").exists()
+ and (root / ".git").exists()
+ and not (root / ".git/shallow").exists()):
+ try:
+ import setuptools_scm
+ except ImportError:
+ pass
+ else:
+ return setuptools_scm.get_version(
+ root=root,
+ dist_name="matplotlib",
+ version_scheme="release-branch-semver",
+ local_scheme="node-and-date",
+ fallback_version=_version.version,
+ )
+ # Get the version from the _version.py file if not in repo or setuptools_scm is
+ # unavailable.
+ return _version.version
+
+
+@_api.caching_module_getattr
+class __getattr__:
+ __version__ = property(lambda self: _get_version())
+ __version_info__ = property(
+ lambda self: _parse_to_version_info(self.__version__))
+
+
+def _check_versions():
+
+ # Quickfix to ensure Microsoft Visual C++ redistributable
+ # DLLs are loaded before importing kiwisolver
+ from . import ft2font # noqa: F401
+
+ for modname, minver in [
+ ("cycler", "0.10"),
+ ("dateutil", "2.7"),
+ ("kiwisolver", "1.3.1"),
+ ("numpy", "1.23"),
+ ("pyparsing", "2.3.1"),
+ ]:
+ module = importlib.import_module(modname)
+ if parse_version(module.__version__) < parse_version(minver):
+ raise ImportError(f"Matplotlib requires {modname}>={minver}; "
+ f"you have {module.__version__}")
+
+
+_check_versions()
+
+
+# The decorator ensures this always returns the same handler (and it is only
+# attached once).
+@functools.cache
+def _ensure_handler():
+ """
+ The first time this function is called, attach a `StreamHandler` using the
+ same format as `logging.basicConfig` to the Matplotlib root logger.
+
+ Return this handler every time this function is called.
+ """
+ handler = logging.StreamHandler()
+ handler.setFormatter(logging.Formatter(logging.BASIC_FORMAT))
+ _log.addHandler(handler)
+ return handler
+
+
+def set_loglevel(level):
+ """
+ Configure Matplotlib's logging levels.
+
+ Matplotlib uses the standard library `logging` framework under the root
+ logger 'matplotlib'. This is a helper function to:
+
+ - set Matplotlib's root logger level
+ - set the root logger handler's level, creating the handler
+ if it does not exist yet
+
+ Typically, one should call ``set_loglevel("info")`` or
+ ``set_loglevel("debug")`` to get additional debugging information.
+
+ Users or applications that are installing their own logging handlers
+ may want to directly manipulate ``logging.getLogger('matplotlib')`` rather
+ than use this function.
+
+ Parameters
+ ----------
+ level : {"notset", "debug", "info", "warning", "error", "critical"}
+ The log level of the handler.
+
+ Notes
+ -----
+ The first time this function is called, an additional handler is attached
+ to Matplotlib's root handler; this handler is reused every time and this
+ function simply manipulates the logger and handler's level.
+
+ """
+ _log.setLevel(level.upper())
+ _ensure_handler().setLevel(level.upper())
+
+
+def _logged_cached(fmt, func=None):
+ """
+ Decorator that logs a function's return value, and memoizes that value.
+
+ After ::
+
+ @_logged_cached(fmt)
+ def func(): ...
+
+ the first call to *func* will log its return value at the DEBUG level using
+ %-format string *fmt*, and memoize it; later calls to *func* will directly
+ return that value.
+ """
+ if func is None: # Return the actual decorator.
+ return functools.partial(_logged_cached, fmt)
+
+ called = False
+ ret = None
+
+ @functools.wraps(func)
+ def wrapper(**kwargs):
+ nonlocal called, ret
+ if not called:
+ ret = func(**kwargs)
+ called = True
+ _log.debug(fmt, ret)
+ return ret
+
+ return wrapper
+
+
+_ExecInfo = namedtuple("_ExecInfo", "executable raw_version version")
+
+
+class ExecutableNotFoundError(FileNotFoundError):
+ """
+ Error raised when an executable that Matplotlib optionally
+ depends on can't be found.
+ """
+ pass
+
+
+@functools.cache
+def _get_executable_info(name):
+ """
+ Get the version of some executable that Matplotlib optionally depends on.
+
+ .. warning::
+ The list of executables that this function supports is set according to
+ Matplotlib's internal needs, and may change without notice.
+
+ Parameters
+ ----------
+ name : str
+ The executable to query. The following values are currently supported:
+ "dvipng", "gs", "inkscape", "magick", "pdftocairo", "pdftops". This
+ list is subject to change without notice.
+
+ Returns
+ -------
+ tuple
+ A namedtuple with fields ``executable`` (`str`) and ``version``
+ (`packaging.Version`, or ``None`` if the version cannot be determined).
+
+ Raises
+ ------
+ ExecutableNotFoundError
+ If the executable is not found or older than the oldest version
+ supported by Matplotlib. For debugging purposes, it is also
+ possible to "hide" an executable from Matplotlib by adding it to the
+ :envvar:`_MPLHIDEEXECUTABLES` environment variable (a comma-separated
+ list), which must be set prior to any calls to this function.
+ ValueError
+ If the executable is not one that we know how to query.
+ """
+
+ def impl(args, regex, min_ver=None, ignore_exit_code=False):
+ # Execute the subprocess specified by args; capture stdout and stderr.
+ # Search for a regex match in the output; if the match succeeds, the
+ # first group of the match is the version.
+ # Return an _ExecInfo if the executable exists, and has a version of
+ # at least min_ver (if set); else, raise ExecutableNotFoundError.
+ try:
+ output = subprocess.check_output(
+ args, stderr=subprocess.STDOUT,
+ text=True, errors="replace")
+ except subprocess.CalledProcessError as _cpe:
+ if ignore_exit_code:
+ output = _cpe.output
+ else:
+ raise ExecutableNotFoundError(str(_cpe)) from _cpe
+ except OSError as _ose:
+ raise ExecutableNotFoundError(str(_ose)) from _ose
+ match = re.search(regex, output)
+ if match:
+ raw_version = match.group(1)
+ version = parse_version(raw_version)
+ if min_ver is not None and version < parse_version(min_ver):
+ raise ExecutableNotFoundError(
+ f"You have {args[0]} version {version} but the minimum "
+ f"version supported by Matplotlib is {min_ver}")
+ return _ExecInfo(args[0], raw_version, version)
+ else:
+ raise ExecutableNotFoundError(
+ f"Failed to determine the version of {args[0]} from "
+ f"{' '.join(args)}, which output {output}")
+
+ if name in os.environ.get("_MPLHIDEEXECUTABLES", "").split(","):
+ raise ExecutableNotFoundError(f"{name} was hidden")
+
+ if name == "dvipng":
+ return impl(["dvipng", "-version"], "(?m)^dvipng(?: .*)? (.+)", "1.6")
+ elif name == "gs":
+ execs = (["gswin32c", "gswin64c", "mgs", "gs"] # "mgs" for miktex.
+ if sys.platform == "win32" else
+ ["gs"])
+ for e in execs:
+ try:
+ return impl([e, "--version"], "(.*)", "9")
+ except ExecutableNotFoundError:
+ pass
+ message = "Failed to find a Ghostscript installation"
+ raise ExecutableNotFoundError(message)
+ elif name == "inkscape":
+ try:
+ # Try headless option first (needed for Inkscape version < 1.0):
+ return impl(["inkscape", "--without-gui", "-V"],
+ "Inkscape ([^ ]*)")
+ except ExecutableNotFoundError:
+ pass # Suppress exception chaining.
+ # If --without-gui is not accepted, we may be using Inkscape >= 1.0 so
+ # try without it:
+ return impl(["inkscape", "-V"], "Inkscape ([^ ]*)")
+ elif name == "magick":
+ if sys.platform == "win32":
+ # Check the registry to avoid confusing ImageMagick's convert with
+ # Windows's builtin convert.exe.
+ import winreg
+ binpath = ""
+ for flag in [0, winreg.KEY_WOW64_32KEY, winreg.KEY_WOW64_64KEY]:
+ try:
+ with winreg.OpenKeyEx(
+ winreg.HKEY_LOCAL_MACHINE,
+ r"Software\Imagemagick\Current",
+ 0, winreg.KEY_QUERY_VALUE | flag) as hkey:
+ binpath = winreg.QueryValueEx(hkey, "BinPath")[0]
+ except OSError:
+ pass
+ path = None
+ if binpath:
+ for name in ["convert.exe", "magick.exe"]:
+ candidate = Path(binpath, name)
+ if candidate.exists():
+ path = str(candidate)
+ break
+ if path is None:
+ raise ExecutableNotFoundError(
+ "Failed to find an ImageMagick installation")
+ else:
+ path = "convert"
+ info = impl([path, "--version"], r"^Version: ImageMagick (\S*)")
+ if info.raw_version == "7.0.10-34":
+ # https://github.com/ImageMagick/ImageMagick/issues/2720
+ raise ExecutableNotFoundError(
+ f"You have ImageMagick {info.version}, which is unsupported")
+ return info
+ elif name == "pdftocairo":
+ return impl(["pdftocairo", "-v"], "pdftocairo version (.*)")
+ elif name == "pdftops":
+ info = impl(["pdftops", "-v"], "^pdftops version (.*)",
+ ignore_exit_code=True)
+ if info and not (
+ 3 <= info.version.major or
+ # poppler version numbers.
+ parse_version("0.9") <= info.version < parse_version("1.0")):
+ raise ExecutableNotFoundError(
+ f"You have pdftops version {info.version} but the minimum "
+ f"version supported by Matplotlib is 3.0")
+ return info
+ else:
+ raise ValueError(f"Unknown executable: {name!r}")
+
+
+def _get_xdg_config_dir():
+ """
+ Return the XDG configuration directory, according to the XDG base
+ directory spec:
+
+ https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+ """
+ return os.environ.get('XDG_CONFIG_HOME') or str(Path.home() / ".config")
+
+
+def _get_xdg_cache_dir():
+ """
+ Return the XDG cache directory, according to the XDG base directory spec:
+
+ https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+ """
+ return os.environ.get('XDG_CACHE_HOME') or str(Path.home() / ".cache")
+
+
+def _get_config_or_cache_dir(xdg_base_getter):
+ configdir = os.environ.get('MPLCONFIGDIR')
+ if configdir:
+ configdir = Path(configdir)
+ elif sys.platform.startswith(('linux', 'freebsd')):
+ # Only call _xdg_base_getter here so that MPLCONFIGDIR is tried first,
+ # as _xdg_base_getter can throw.
+ configdir = Path(xdg_base_getter(), "matplotlib")
+ else:
+ configdir = Path.home() / ".matplotlib"
+ # Resolve the path to handle potential issues with inaccessible symlinks.
+ configdir = configdir.resolve()
+ try:
+ configdir.mkdir(parents=True, exist_ok=True)
+ except OSError as exc:
+ _log.warning("mkdir -p failed for path %s: %s", configdir, exc)
+ else:
+ if os.access(str(configdir), os.W_OK) and configdir.is_dir():
+ return str(configdir)
+ _log.warning("%s is not a writable directory", configdir)
+ # If the config or cache directory cannot be created or is not a writable
+ # directory, create a temporary one.
+ try:
+ tmpdir = tempfile.mkdtemp(prefix="matplotlib-")
+ except OSError as exc:
+ raise OSError(
+ f"Matplotlib requires access to a writable cache directory, but there "
+ f"was an issue with the default path ({configdir}), and a temporary "
+ f"directory could not be created; set the MPLCONFIGDIR environment "
+ f"variable to a writable directory") from exc
+ os.environ["MPLCONFIGDIR"] = tmpdir
+ atexit.register(shutil.rmtree, tmpdir)
+ _log.warning(
+ "Matplotlib created a temporary cache directory at %s because there was "
+ "an issue with the default path (%s); it is highly recommended to set the "
+ "MPLCONFIGDIR environment variable to a writable directory, in particular to "
+ "speed up the import of Matplotlib and to better support multiprocessing.",
+ tmpdir, configdir)
+ return tmpdir
+
+
+@_logged_cached('CONFIGDIR=%s')
+def get_configdir():
+ """
+ Return the string path of the configuration directory.
+
+ The directory is chosen as follows:
+
+ 1. If the MPLCONFIGDIR environment variable is supplied, choose that.
+ 2. On Linux, follow the XDG specification and look first in
+ ``$XDG_CONFIG_HOME``, if defined, or ``$HOME/.config``. On other
+ platforms, choose ``$HOME/.matplotlib``.
+ 3. If the chosen directory exists and is writable, use that as the
+ configuration directory.
+ 4. Else, create a temporary directory, and use it as the configuration
+ directory.
+ """
+ return _get_config_or_cache_dir(_get_xdg_config_dir)
+
+
+@_logged_cached('CACHEDIR=%s')
+def get_cachedir():
+ """
+ Return the string path of the cache directory.
+
+ The procedure used to find the directory is the same as for
+ `get_configdir`, except using ``$XDG_CACHE_HOME``/``$HOME/.cache`` instead.
+ """
+ return _get_config_or_cache_dir(_get_xdg_cache_dir)
+
+
+@_logged_cached('matplotlib data path: %s')
+def get_data_path():
+ """Return the path to Matplotlib data."""
+ return str(Path(__file__).with_name("mpl-data"))
+
+
+def matplotlib_fname():
+ """
+ Get the location of the config file.
+
+ The file location is determined in the following order
+
+ - ``$PWD/matplotlibrc``
+ - ``$MATPLOTLIBRC`` if it is not a directory
+ - ``$MATPLOTLIBRC/matplotlibrc``
+ - ``$MPLCONFIGDIR/matplotlibrc``
+ - On Linux,
+ - ``$XDG_CONFIG_HOME/matplotlib/matplotlibrc`` (if ``$XDG_CONFIG_HOME``
+ is defined)
+ - or ``$HOME/.config/matplotlib/matplotlibrc`` (if ``$XDG_CONFIG_HOME``
+ is not defined)
+ - On other platforms,
+ - ``$HOME/.matplotlib/matplotlibrc`` if ``$HOME`` is defined
+ - Lastly, it looks in ``$MATPLOTLIBDATA/matplotlibrc``, which should always
+ exist.
+ """
+
+ def gen_candidates():
+ # rely on down-stream code to make absolute. This protects us
+ # from having to directly get the current working directory
+ # which can fail if the user has ended up with a cwd that is
+ # non-existent.
+ yield 'matplotlibrc'
+ try:
+ matplotlibrc = os.environ['MATPLOTLIBRC']
+ except KeyError:
+ pass
+ else:
+ yield matplotlibrc
+ yield os.path.join(matplotlibrc, 'matplotlibrc')
+ yield os.path.join(get_configdir(), 'matplotlibrc')
+ yield os.path.join(get_data_path(), 'matplotlibrc')
+
+ for fname in gen_candidates():
+ if os.path.exists(fname) and not os.path.isdir(fname):
+ return fname
+
+ raise RuntimeError("Could not find matplotlibrc file; your Matplotlib "
+ "install is broken")
+
+
+# rcParams deprecated and automatically mapped to another key.
+# Values are tuples of (version, new_name, f_old2new, f_new2old).
+_deprecated_map = {}
+# rcParams deprecated; some can manually be mapped to another key.
+# Values are tuples of (version, new_name_or_None).
+_deprecated_ignore_map = {}
+# rcParams deprecated; can use None to suppress warnings; remain actually
+# listed in the rcParams.
+# Values are tuples of (version,)
+_deprecated_remain_as_none = {}
+
+
+@_docstring.Substitution(
+ "\n".join(map("- {}".format, sorted(rcsetup._validators, key=str.lower)))
+)
+class RcParams(MutableMapping, dict):
+ """
+ A dict-like key-value store for config parameters, including validation.
+
+ Validating functions are defined and associated with rc parameters in
+ :mod:`matplotlib.rcsetup`.
+
+ The list of rcParams is:
+
+ %s
+
+ See Also
+ --------
+ :ref:`customizing-with-matplotlibrc-files`
+ """
+
+ validate = rcsetup._validators
+
+ # validate values on the way in
+ def __init__(self, *args, **kwargs):
+ self.update(*args, **kwargs)
+
+ def _set(self, key, val):
+ """
+ Directly write data bypassing deprecation and validation logic.
+
+ Notes
+ -----
+ As end user or downstream library you almost always should use
+ ``rcParams[key] = val`` and not ``_set()``.
+
+ There are only very few special cases that need direct data access.
+ These cases previously used ``dict.__setitem__(rcParams, key, val)``,
+ which is now deprecated and replaced by ``rcParams._set(key, val)``.
+
+ Even though private, we guarantee API stability for ``rcParams._set``,
+ i.e. it is subject to Matplotlib's API and deprecation policy.
+
+ :meta public:
+ """
+ dict.__setitem__(self, key, val)
+
+ def _get(self, key):
+ """
+ Directly read data bypassing deprecation, backend and validation
+ logic.
+
+ Notes
+ -----
+ As end user or downstream library you almost always should use
+ ``val = rcParams[key]`` and not ``_get()``.
+
+ There are only very few special cases that need direct data access.
+ These cases previously used ``dict.__getitem__(rcParams, key, val)``,
+ which is now deprecated and replaced by ``rcParams._get(key)``.
+
+ Even though private, we guarantee API stability for ``rcParams._get``,
+ i.e. it is subject to Matplotlib's API and deprecation policy.
+
+ :meta public:
+ """
+ return dict.__getitem__(self, key)
+
+ def _update_raw(self, other_params):
+ """
+ Directly update the data from *other_params*, bypassing deprecation,
+ backend and validation logic on both sides.
+
+ This ``rcParams._update_raw(params)`` replaces the previous pattern
+ ``dict.update(rcParams, params)``.
+
+ Parameters
+ ----------
+ other_params : dict or `.RcParams`
+ The input mapping from which to update.
+ """
+ if isinstance(other_params, RcParams):
+ other_params = dict.items(other_params)
+ dict.update(self, other_params)
+
+ def _ensure_has_backend(self):
+ """
+ Ensure that a "backend" entry exists.
+
+ Normally, the default matplotlibrc file contains *no* entry for "backend" (the
+ corresponding line starts with ##, not #; we fill in _auto_backend_sentinel
+ in that case. However, packagers can set a different default backend
+ (resulting in a normal `#backend: foo` line) in which case we should *not*
+ fill in _auto_backend_sentinel.
+ """
+ dict.setdefault(self, "backend", rcsetup._auto_backend_sentinel)
+
+ def __setitem__(self, key, val):
+ try:
+ if key in _deprecated_map:
+ version, alt_key, alt_val, inverse_alt = _deprecated_map[key]
+ _api.warn_deprecated(
+ version, name=key, obj_type="rcparam", alternative=alt_key)
+ key = alt_key
+ val = alt_val(val)
+ elif key in _deprecated_remain_as_none and val is not None:
+ version, = _deprecated_remain_as_none[key]
+ _api.warn_deprecated(version, name=key, obj_type="rcparam")
+ elif key in _deprecated_ignore_map:
+ version, alt_key = _deprecated_ignore_map[key]
+ _api.warn_deprecated(
+ version, name=key, obj_type="rcparam", alternative=alt_key)
+ return
+ elif key == 'backend':
+ if val is rcsetup._auto_backend_sentinel:
+ if 'backend' in self:
+ return
+ try:
+ cval = self.validate[key](val)
+ except ValueError as ve:
+ raise ValueError(f"Key {key}: {ve}") from None
+ self._set(key, cval)
+ except KeyError as err:
+ raise KeyError(
+ f"{key} is not a valid rc parameter (see rcParams.keys() for "
+ f"a list of valid parameters)") from err
+
+ def __getitem__(self, key):
+ if key in _deprecated_map:
+ version, alt_key, alt_val, inverse_alt = _deprecated_map[key]
+ _api.warn_deprecated(
+ version, name=key, obj_type="rcparam", alternative=alt_key)
+ return inverse_alt(self._get(alt_key))
+
+ elif key in _deprecated_ignore_map:
+ version, alt_key = _deprecated_ignore_map[key]
+ _api.warn_deprecated(
+ version, name=key, obj_type="rcparam", alternative=alt_key)
+ return self._get(alt_key) if alt_key else None
+
+ # In theory, this should only ever be used after the global rcParams
+ # has been set up, but better be safe e.g. in presence of breakpoints.
+ elif key == "backend" and self is globals().get("rcParams"):
+ val = self._get(key)
+ if val is rcsetup._auto_backend_sentinel:
+ from matplotlib import pyplot as plt
+ plt.switch_backend(rcsetup._auto_backend_sentinel)
+
+ return self._get(key)
+
+ def _get_backend_or_none(self):
+ """Get the requested backend, if any, without triggering resolution."""
+ backend = self._get("backend")
+ return None if backend is rcsetup._auto_backend_sentinel else backend
+
+ def __repr__(self):
+ class_name = self.__class__.__name__
+ indent = len(class_name) + 1
+ with _api.suppress_matplotlib_deprecation_warning():
+ repr_split = pprint.pformat(dict(self), indent=1,
+ width=80 - indent).split('\n')
+ repr_indented = ('\n' + ' ' * indent).join(repr_split)
+ return f'{class_name}({repr_indented})'
+
+ def __str__(self):
+ return '\n'.join(map('{0[0]}: {0[1]}'.format, sorted(self.items())))
+
+ def __iter__(self):
+ """Yield sorted list of keys."""
+ with _api.suppress_matplotlib_deprecation_warning():
+ yield from sorted(dict.__iter__(self))
+
+ def __len__(self):
+ return dict.__len__(self)
+
+ def find_all(self, pattern):
+ """
+ Return the subset of this RcParams dictionary whose keys match,
+ using :func:`re.search`, the given ``pattern``.
+
+ .. note::
+
+ Changes to the returned dictionary are *not* propagated to
+ the parent RcParams dictionary.
+
+ """
+ pattern_re = re.compile(pattern)
+ return RcParams((key, value)
+ for key, value in self.items()
+ if pattern_re.search(key))
+
+ def copy(self):
+ """Copy this RcParams instance."""
+ rccopy = RcParams()
+ for k in self: # Skip deprecations and revalidation.
+ rccopy._set(k, self._get(k))
+ return rccopy
+
+
+def rc_params(fail_on_error=False):
+ """Construct a `RcParams` instance from the default Matplotlib rc file."""
+ return rc_params_from_file(matplotlib_fname(), fail_on_error)
+
+
+@functools.cache
+def _get_ssl_context():
+ try:
+ import certifi
+ except ImportError:
+ _log.debug("Could not import certifi.")
+ return None
+ import ssl
+ return ssl.create_default_context(cafile=certifi.where())
+
+
+@contextlib.contextmanager
+def _open_file_or_url(fname):
+ if (isinstance(fname, str)
+ and fname.startswith(('http://', 'https://', 'ftp://', 'file:'))):
+ import urllib.request
+ ssl_ctx = _get_ssl_context()
+ if ssl_ctx is None:
+ _log.debug(
+ "Could not get certifi ssl context, https may not work."
+ )
+ with urllib.request.urlopen(fname, context=ssl_ctx) as f:
+ yield (line.decode('utf-8') for line in f)
+ else:
+ fname = os.path.expanduser(fname)
+ with open(fname, encoding='utf-8') as f:
+ yield f
+
+
+def _rc_params_in_file(fname, transform=lambda x: x, fail_on_error=False):
+ """
+ Construct a `RcParams` instance from file *fname*.
+
+ Unlike `rc_params_from_file`, the configuration class only contains the
+ parameters specified in the file (i.e. default values are not filled in).
+
+ Parameters
+ ----------
+ fname : path-like
+ The loaded file.
+ transform : callable, default: the identity function
+ A function called on each individual line of the file to transform it,
+ before further parsing.
+ fail_on_error : bool, default: False
+ Whether invalid entries should result in an exception or a warning.
+ """
+ import matplotlib as mpl
+ rc_temp = {}
+ with _open_file_or_url(fname) as fd:
+ try:
+ for line_no, line in enumerate(fd, 1):
+ line = transform(line)
+ strippedline = cbook._strip_comment(line)
+ if not strippedline:
+ continue
+ tup = strippedline.split(':', 1)
+ if len(tup) != 2:
+ _log.warning('Missing colon in file %r, line %d (%r)',
+ fname, line_no, line.rstrip('\n'))
+ continue
+ key, val = tup
+ key = key.strip()
+ val = val.strip()
+ if val.startswith('"') and val.endswith('"'):
+ val = val[1:-1] # strip double quotes
+ if key in rc_temp:
+ _log.warning('Duplicate key in file %r, line %d (%r)',
+ fname, line_no, line.rstrip('\n'))
+ rc_temp[key] = (val, line, line_no)
+ except UnicodeDecodeError:
+ _log.warning('Cannot decode configuration file %r as utf-8.',
+ fname)
+ raise
+
+ config = RcParams()
+
+ for key, (val, line, line_no) in rc_temp.items():
+ if key in rcsetup._validators:
+ if fail_on_error:
+ config[key] = val # try to convert to proper type or raise
+ else:
+ try:
+ config[key] = val # try to convert to proper type or skip
+ except Exception as msg:
+ _log.warning('Bad value in file %r, line %d (%r): %s',
+ fname, line_no, line.rstrip('\n'), msg)
+ elif key in _deprecated_ignore_map:
+ version, alt_key = _deprecated_ignore_map[key]
+ _api.warn_deprecated(
+ version, name=key, alternative=alt_key, obj_type='rcparam',
+ addendum="Please update your matplotlibrc.")
+ else:
+ # __version__ must be looked up as an attribute to trigger the
+ # module-level __getattr__.
+ version = ('main' if '.post' in mpl.__version__
+ else f'v{mpl.__version__}')
+ _log.warning("""
+Bad key %(key)s in file %(fname)s, line %(line_no)s (%(line)r)
+You probably need to get an updated matplotlibrc file from
+https://github.com/matplotlib/matplotlib/blob/%(version)s/lib/matplotlib/mpl-data/matplotlibrc
+or from the matplotlib source distribution""",
+ dict(key=key, fname=fname, line_no=line_no,
+ line=line.rstrip('\n'), version=version))
+ return config
+
+
+def rc_params_from_file(fname, fail_on_error=False, use_default_template=True):
+ """
+ Construct a `RcParams` from file *fname*.
+
+ Parameters
+ ----------
+ fname : str or path-like
+ A file with Matplotlib rc settings.
+ fail_on_error : bool
+ If True, raise an error when the parser fails to convert a parameter.
+ use_default_template : bool
+ If True, initialize with default parameters before updating with those
+ in the given file. If False, the configuration class only contains the
+ parameters specified in the file. (Useful for updating dicts.)
+ """
+ config_from_file = _rc_params_in_file(fname, fail_on_error=fail_on_error)
+
+ if not use_default_template:
+ return config_from_file
+
+ with _api.suppress_matplotlib_deprecation_warning():
+ config = RcParams({**rcParamsDefault, **config_from_file})
+
+ if "".join(config['text.latex.preamble']):
+ _log.info("""
+*****************************************************************
+You have the following UNSUPPORTED LaTeX preamble customizations:
+%s
+Please do not ask for support with these customizations active.
+*****************************************************************
+""", '\n'.join(config['text.latex.preamble']))
+ _log.debug('loaded rc file %s', fname)
+
+ return config
+
+
+rcParamsDefault = _rc_params_in_file(
+ cbook._get_data_path("matplotlibrc"),
+ # Strip leading comment.
+ transform=lambda line: line[1:] if line.startswith("#") else line,
+ fail_on_error=True)
+rcParamsDefault._update_raw(rcsetup._hardcoded_defaults)
+rcParamsDefault._ensure_has_backend()
+
+rcParams = RcParams() # The global instance.
+rcParams._update_raw(rcParamsDefault)
+rcParams._update_raw(_rc_params_in_file(matplotlib_fname()))
+rcParamsOrig = rcParams.copy()
+with _api.suppress_matplotlib_deprecation_warning():
+ # This also checks that all rcParams are indeed listed in the template.
+ # Assigning to rcsetup.defaultParams is left only for backcompat.
+ defaultParams = rcsetup.defaultParams = {
+ # We want to resolve deprecated rcParams, but not backend...
+ key: [(rcsetup._auto_backend_sentinel if key == "backend" else
+ rcParamsDefault[key]),
+ validator]
+ for key, validator in rcsetup._validators.items()}
+if rcParams['axes.formatter.use_locale']:
+ locale.setlocale(locale.LC_ALL, '')
+
+
+def rc(group, **kwargs):
+ """
+ Set the current `.rcParams`. *group* is the grouping for the rc, e.g.,
+ for ``lines.linewidth`` the group is ``lines``, for
+ ``axes.facecolor``, the group is ``axes``, and so on. Group may
+ also be a list or tuple of group names, e.g., (*xtick*, *ytick*).
+ *kwargs* is a dictionary attribute name/value pairs, e.g.,::
+
+ rc('lines', linewidth=2, color='r')
+
+ sets the current `.rcParams` and is equivalent to::
+
+ rcParams['lines.linewidth'] = 2
+ rcParams['lines.color'] = 'r'
+
+ The following aliases are available to save typing for interactive users:
+
+ ===== =================
+ Alias Property
+ ===== =================
+ 'lw' 'linewidth'
+ 'ls' 'linestyle'
+ 'c' 'color'
+ 'fc' 'facecolor'
+ 'ec' 'edgecolor'
+ 'mew' 'markeredgewidth'
+ 'aa' 'antialiased'
+ ===== =================
+
+ Thus you could abbreviate the above call as::
+
+ rc('lines', lw=2, c='r')
+
+ Note you can use python's kwargs dictionary facility to store
+ dictionaries of default parameters. e.g., you can customize the
+ font rc as follows::
+
+ font = {'family' : 'monospace',
+ 'weight' : 'bold',
+ 'size' : 'larger'}
+ rc('font', **font) # pass in the font dict as kwargs
+
+ This enables you to easily switch between several configurations. Use
+ ``matplotlib.style.use('default')`` or :func:`~matplotlib.rcdefaults` to
+ restore the default `.rcParams` after changes.
+
+ Notes
+ -----
+ Similar functionality is available by using the normal dict interface, i.e.
+ ``rcParams.update({"lines.linewidth": 2, ...})`` (but ``rcParams.update``
+ does not support abbreviations or grouping).
+ """
+
+ aliases = {
+ 'lw': 'linewidth',
+ 'ls': 'linestyle',
+ 'c': 'color',
+ 'fc': 'facecolor',
+ 'ec': 'edgecolor',
+ 'mew': 'markeredgewidth',
+ 'aa': 'antialiased',
+ }
+
+ if isinstance(group, str):
+ group = (group,)
+ for g in group:
+ for k, v in kwargs.items():
+ name = aliases.get(k) or k
+ key = f'{g}.{name}'
+ try:
+ rcParams[key] = v
+ except KeyError as err:
+ raise KeyError(('Unrecognized key "%s" for group "%s" and '
+ 'name "%s"') % (key, g, name)) from err
+
+
+def rcdefaults():
+ """
+ Restore the `.rcParams` from Matplotlib's internal default style.
+
+ Style-blacklisted `.rcParams` (defined in
+ ``matplotlib.style.core.STYLE_BLACKLIST``) are not updated.
+
+ See Also
+ --------
+ matplotlib.rc_file_defaults
+ Restore the `.rcParams` from the rc file originally loaded by
+ Matplotlib.
+ matplotlib.style.use
+ Use a specific style file. Call ``style.use('default')`` to restore
+ the default style.
+ """
+ # Deprecation warnings were already handled when creating rcParamsDefault,
+ # no need to reemit them here.
+ with _api.suppress_matplotlib_deprecation_warning():
+ from .style.core import STYLE_BLACKLIST
+ rcParams.clear()
+ rcParams.update({k: v for k, v in rcParamsDefault.items()
+ if k not in STYLE_BLACKLIST})
+
+
+def rc_file_defaults():
+ """
+ Restore the `.rcParams` from the original rc file loaded by Matplotlib.
+
+ Style-blacklisted `.rcParams` (defined in
+ ``matplotlib.style.core.STYLE_BLACKLIST``) are not updated.
+ """
+ # Deprecation warnings were already handled when creating rcParamsOrig, no
+ # need to reemit them here.
+ with _api.suppress_matplotlib_deprecation_warning():
+ from .style.core import STYLE_BLACKLIST
+ rcParams.update({k: rcParamsOrig[k] for k in rcParamsOrig
+ if k not in STYLE_BLACKLIST})
+
+
+def rc_file(fname, *, use_default_template=True):
+ """
+ Update `.rcParams` from file.
+
+ Style-blacklisted `.rcParams` (defined in
+ ``matplotlib.style.core.STYLE_BLACKLIST``) are not updated.
+
+ Parameters
+ ----------
+ fname : str or path-like
+ A file with Matplotlib rc settings.
+
+ use_default_template : bool
+ If True, initialize with default parameters before updating with those
+ in the given file. If False, the current configuration persists
+ and only the parameters specified in the file are updated.
+ """
+ # Deprecation warnings were already handled in rc_params_from_file, no need
+ # to reemit them here.
+ with _api.suppress_matplotlib_deprecation_warning():
+ from .style.core import STYLE_BLACKLIST
+ rc_from_file = rc_params_from_file(
+ fname, use_default_template=use_default_template)
+ rcParams.update({k: rc_from_file[k] for k in rc_from_file
+ if k not in STYLE_BLACKLIST})
+
+
+@contextlib.contextmanager
+def rc_context(rc=None, fname=None):
+ """
+ Return a context manager for temporarily changing rcParams.
+
+ The :rc:`backend` will not be reset by the context manager.
+
+ rcParams changed both through the context manager invocation and
+ in the body of the context will be reset on context exit.
+
+ Parameters
+ ----------
+ rc : dict
+ The rcParams to temporarily set.
+ fname : str or path-like
+ A file with Matplotlib rc settings. If both *fname* and *rc* are given,
+ settings from *rc* take precedence.
+
+ See Also
+ --------
+ :ref:`customizing-with-matplotlibrc-files`
+
+ Examples
+ --------
+ Passing explicit values via a dict::
+
+ with mpl.rc_context({'interactive': False}):
+ fig, ax = plt.subplots()
+ ax.plot(range(3), range(3))
+ fig.savefig('example.png')
+ plt.close(fig)
+
+ Loading settings from a file::
+
+ with mpl.rc_context(fname='print.rc'):
+ plt.plot(x, y) # uses 'print.rc'
+
+ Setting in the context body::
+
+ with mpl.rc_context():
+ # will be reset
+ mpl.rcParams['lines.linewidth'] = 5
+ plt.plot(x, y)
+
+ """
+ orig = dict(rcParams.copy())
+ del orig['backend']
+ try:
+ if fname:
+ rc_file(fname)
+ if rc:
+ rcParams.update(rc)
+ yield
+ finally:
+ rcParams._update_raw(orig) # Revert to the original rcs.
+
+
+def use(backend, *, force=True):
+ """
+ Select the backend used for rendering and GUI integration.
+
+ If pyplot is already imported, `~matplotlib.pyplot.switch_backend` is used
+ and if the new backend is different than the current backend, all Figures
+ will be closed.
+
+ Parameters
+ ----------
+ backend : str
+ The backend to switch to. This can either be one of the standard
+ backend names, which are case-insensitive:
+
+ - interactive backends:
+ GTK3Agg, GTK3Cairo, GTK4Agg, GTK4Cairo, MacOSX, nbAgg, notebook, QtAgg,
+ QtCairo, TkAgg, TkCairo, WebAgg, WX, WXAgg, WXCairo, Qt5Agg, Qt5Cairo
+
+ - non-interactive backends:
+ agg, cairo, pdf, pgf, ps, svg, template
+
+ or a string of the form: ``module://my.module.name``.
+
+ notebook is a synonym for nbAgg.
+
+ Switching to an interactive backend is not possible if an unrelated
+ event loop has already been started (e.g., switching to GTK3Agg if a
+ TkAgg window has already been opened). Switching to a non-interactive
+ backend is always possible.
+
+ force : bool, default: True
+ If True (the default), raise an `ImportError` if the backend cannot be
+ set up (either because it fails to import, or because an incompatible
+ GUI interactive framework is already running); if False, silently
+ ignore the failure.
+
+ See Also
+ --------
+ :ref:`backends`
+ matplotlib.get_backend
+ matplotlib.pyplot.switch_backend
+
+ """
+ name = rcsetup.validate_backend(backend)
+ # don't (prematurely) resolve the "auto" backend setting
+ if rcParams._get_backend_or_none() == name:
+ # Nothing to do if the requested backend is already set
+ pass
+ else:
+ # if pyplot is not already imported, do not import it. Doing
+ # so may trigger a `plt.switch_backend` to the _default_ backend
+ # before we get a chance to change to the one the user just requested
+ plt = sys.modules.get('matplotlib.pyplot')
+ # if pyplot is imported, then try to change backends
+ if plt is not None:
+ try:
+ # we need this import check here to re-raise if the
+ # user does not have the libraries to support their
+ # chosen backend installed.
+ plt.switch_backend(name)
+ except ImportError:
+ if force:
+ raise
+ # if we have not imported pyplot, then we can set the rcParam
+ # value which will be respected when the user finally imports
+ # pyplot
+ else:
+ rcParams['backend'] = backend
+ # if the user has asked for a given backend, do not helpfully
+ # fallback
+ rcParams['backend_fallback'] = False
+
+
+if os.environ.get('MPLBACKEND'):
+ rcParams['backend'] = os.environ.get('MPLBACKEND')
+
+
+def get_backend(*, auto_select=True):
+ """
+ Return the name of the current backend.
+
+ Parameters
+ ----------
+ auto_select : bool, default: True
+ Whether to trigger backend resolution if no backend has been
+ selected so far. If True, this ensures that a valid backend
+ is returned. If False, this returns None if no backend has been
+ selected so far.
+
+ .. versionadded:: 3.10
+
+ .. admonition:: Provisional
+
+ The *auto_select* flag is provisional. It may be changed or removed
+ without prior warning.
+
+ See Also
+ --------
+ matplotlib.use
+ """
+ if auto_select:
+ return rcParams['backend']
+ else:
+ backend = rcParams._get('backend')
+ if backend is rcsetup._auto_backend_sentinel:
+ return None
+ else:
+ return backend
+
+
+def interactive(b):
+ """
+ Set whether to redraw after every plotting command (e.g. `.pyplot.xlabel`).
+ """
+ rcParams['interactive'] = b
+
+
+def is_interactive():
+ """
+ Return whether to redraw after every plotting command.
+
+ .. note::
+
+ This function is only intended for use in backends. End users should
+ use `.pyplot.isinteractive` instead.
+ """
+ return rcParams['interactive']
+
+
+def _val_or_rc(val, rc_name):
+ """
+ If *val* is None, return ``mpl.rcParams[rc_name]``, otherwise return val.
+ """
+ return val if val is not None else rcParams[rc_name]
+
+
+def _init_tests():
+ # The version of FreeType to install locally for running the tests. This must match
+ # the value in `meson.build`.
+ LOCAL_FREETYPE_VERSION = '2.6.1'
+
+ from matplotlib import ft2font
+ if (ft2font.__freetype_version__ != LOCAL_FREETYPE_VERSION or
+ ft2font.__freetype_build_type__ != 'local'):
+ _log.warning(
+ "Matplotlib is not built with the correct FreeType version to run tests. "
+ "Rebuild without setting system-freetype=true in Meson setup options. "
+ "Expect many image comparison failures below. "
+ "Expected freetype version %s. "
+ "Found freetype version %s. "
+ "Freetype build type is %slocal.",
+ LOCAL_FREETYPE_VERSION,
+ ft2font.__freetype_version__,
+ "" if ft2font.__freetype_build_type__ == 'local' else "not ")
+
+
+def _replacer(data, value):
+ """
+ Either returns ``data[value]`` or passes ``data`` back, converts either to
+ a sequence.
+ """
+ try:
+ # if key isn't a string don't bother
+ if isinstance(value, str):
+ # try to use __getitem__
+ value = data[value]
+ except Exception:
+ # key does not exist, silently fall back to key
+ pass
+ return cbook.sanitize_sequence(value)
+
+
+def _label_from_arg(y, default_name):
+ try:
+ return y.name
+ except AttributeError:
+ if isinstance(default_name, str):
+ return default_name
+ return None
+
+
+def _add_data_doc(docstring, replace_names):
+ """
+ Add documentation for a *data* field to the given docstring.
+
+ Parameters
+ ----------
+ docstring : str
+ The input docstring.
+ replace_names : list of str or None
+ The list of parameter names which arguments should be replaced by
+ ``data[name]`` (if ``data[name]`` does not throw an exception). If
+ None, replacement is attempted for all arguments.
+
+ Returns
+ -------
+ str
+ The augmented docstring.
+ """
+ if (docstring is None
+ or replace_names is not None and len(replace_names) == 0):
+ return docstring
+ docstring = inspect.cleandoc(docstring)
+
+ data_doc = ("""\
+ If given, all parameters also accept a string ``s``, which is
+ interpreted as ``data[s]`` if ``s`` is a key in ``data``."""
+ if replace_names is None else f"""\
+ If given, the following parameters also accept a string ``s``, which is
+ interpreted as ``data[s]`` if ``s`` is a key in ``data``:
+
+ {', '.join(map('*{}*'.format, replace_names))}""")
+ # using string replacement instead of formatting has the advantages
+ # 1) simpler indent handling
+ # 2) prevent problems with formatting characters '{', '%' in the docstring
+ if _log.level <= logging.DEBUG:
+ # test_data_parameter_replacement() tests against these log messages
+ # make sure to keep message and test in sync
+ if "data : indexable object, optional" not in docstring:
+ _log.debug("data parameter docstring error: no data parameter")
+ if 'DATA_PARAMETER_PLACEHOLDER' not in docstring:
+ _log.debug("data parameter docstring error: missing placeholder")
+ return docstring.replace(' DATA_PARAMETER_PLACEHOLDER', data_doc)
+
+
+def _preprocess_data(func=None, *, replace_names=None, label_namer=None):
+ """
+ A decorator to add a 'data' kwarg to a function.
+
+ When applied::
+
+ @_preprocess_data()
+ def func(ax, *args, **kwargs): ...
+
+ the signature is modified to ``decorated(ax, *args, data=None, **kwargs)``
+ with the following behavior:
+
+ - if called with ``data=None``, forward the other arguments to ``func``;
+ - otherwise, *data* must be a mapping; for any argument passed in as a
+ string ``name``, replace the argument by ``data[name]`` (if this does not
+ throw an exception), then forward the arguments to ``func``.
+
+ In either case, any argument that is a `MappingView` is also converted to a
+ list.
+
+ Parameters
+ ----------
+ replace_names : list of str or None, default: None
+ The list of parameter names for which lookup into *data* should be
+ attempted. If None, replacement is attempted for all arguments.
+ label_namer : str, default: None
+ If set e.g. to "namer" (which must be a kwarg in the function's
+ signature -- not as ``**kwargs``), if the *namer* argument passed in is
+ a (string) key of *data* and no *label* kwarg is passed, then use the
+ (string) value of the *namer* as *label*. ::
+
+ @_preprocess_data(label_namer="foo")
+ def func(foo, label=None): ...
+
+ func("key", data={"key": value})
+ # is equivalent to
+ func.__wrapped__(value, label="key")
+ """
+
+ if func is None: # Return the actual decorator.
+ return functools.partial(
+ _preprocess_data,
+ replace_names=replace_names, label_namer=label_namer)
+
+ sig = inspect.signature(func)
+ varargs_name = None
+ varkwargs_name = None
+ arg_names = []
+ params = list(sig.parameters.values())
+ for p in params:
+ if p.kind is Parameter.VAR_POSITIONAL:
+ varargs_name = p.name
+ elif p.kind is Parameter.VAR_KEYWORD:
+ varkwargs_name = p.name
+ else:
+ arg_names.append(p.name)
+ data_param = Parameter("data", Parameter.KEYWORD_ONLY, default=None)
+ if varkwargs_name:
+ params.insert(-1, data_param)
+ else:
+ params.append(data_param)
+ new_sig = sig.replace(parameters=params)
+ arg_names = arg_names[1:] # remove the first "ax" / self arg
+
+ assert {*arg_names}.issuperset(replace_names or []) or varkwargs_name, (
+ "Matplotlib internal error: invalid replace_names "
+ f"({replace_names!r}) for {func.__name__!r}")
+ assert label_namer is None or label_namer in arg_names, (
+ "Matplotlib internal error: invalid label_namer "
+ f"({label_namer!r}) for {func.__name__!r}")
+
+ @functools.wraps(func)
+ def inner(ax, *args, data=None, **kwargs):
+ if data is None:
+ return func(
+ ax,
+ *map(cbook.sanitize_sequence, args),
+ **{k: cbook.sanitize_sequence(v) for k, v in kwargs.items()})
+
+ bound = new_sig.bind(ax, *args, **kwargs)
+ auto_label = (bound.arguments.get(label_namer)
+ or bound.kwargs.get(label_namer))
+
+ for k, v in bound.arguments.items():
+ if k == varkwargs_name:
+ for k1, v1 in v.items():
+ if replace_names is None or k1 in replace_names:
+ v[k1] = _replacer(data, v1)
+ elif k == varargs_name:
+ if replace_names is None:
+ bound.arguments[k] = tuple(_replacer(data, v1) for v1 in v)
+ else:
+ if replace_names is None or k in replace_names:
+ bound.arguments[k] = _replacer(data, v)
+
+ new_args = bound.args
+ new_kwargs = bound.kwargs
+
+ args_and_kwargs = {**bound.arguments, **bound.kwargs}
+ if label_namer and "label" not in args_and_kwargs:
+ new_kwargs["label"] = _label_from_arg(
+ args_and_kwargs.get(label_namer), auto_label)
+
+ return func(*new_args, **new_kwargs)
+
+ inner.__doc__ = _add_data_doc(inner.__doc__, replace_names)
+ inner.__signature__ = new_sig
+ return inner
+
+
+_log.debug('interactive is %s', is_interactive())
+_log.debug('platform is %s', sys.platform)
+
+
+@_api.deprecated("3.10", alternative="matplotlib.cbook.sanitize_sequence")
+def sanitize_sequence(data):
+ return cbook.sanitize_sequence(data)
+
+
+@_api.deprecated("3.10", alternative="matplotlib.rcsetup.validate_backend")
+def validate_backend(s):
+ return rcsetup.validate_backend(s)
+
+
+# workaround: we must defer colormaps import to after loading rcParams, because
+# colormap creation depends on rcParams
+from matplotlib.cm import _colormaps as colormaps # noqa: E402
+from matplotlib.cm import _multivar_colormaps as multivar_colormaps # noqa: E402
+from matplotlib.cm import _bivar_colormaps as bivar_colormaps # noqa: E402
+from matplotlib.colors import _color_sequences as color_sequences # noqa: E402
diff --git a/moondream/lib/python3.10/site-packages/matplotlib/_afm.py b/moondream/lib/python3.10/site-packages/matplotlib/_afm.py
new file mode 100644
index 0000000000000000000000000000000000000000..558efe16392f7d386f642c86a8b028d10a778f25
--- /dev/null
+++ b/moondream/lib/python3.10/site-packages/matplotlib/_afm.py
@@ -0,0 +1,532 @@
+"""
+A python interface to Adobe Font Metrics Files.
+
+Although a number of other Python implementations exist, and may be more
+complete than this, it was decided not to go with them because they were
+either:
+
+1) copyrighted or used a non-BSD compatible license
+2) had too many dependencies and a free standing lib was needed
+3) did more than needed and it was easier to write afresh rather than
+ figure out how to get just what was needed.
+
+It is pretty easy to use, and has no external dependencies:
+
+>>> import matplotlib as mpl
+>>> from pathlib import Path
+>>> afm_path = Path(mpl.get_data_path(), 'fonts', 'afm', 'ptmr8a.afm')
+>>>
+>>> from matplotlib.afm import AFM
+>>> with afm_path.open('rb') as fh:
+... afm = AFM(fh)
+>>> afm.string_width_height('What the heck?')
+(6220.0, 694)
+>>> afm.get_fontname()
+'Times-Roman'
+>>> afm.get_kern_dist('A', 'f')
+0
+>>> afm.get_kern_dist('A', 'y')
+-92.0
+>>> afm.get_bbox_char('!')
+[130, -9, 238, 676]
+
+As in the Adobe Font Metrics File Format Specification, all dimensions
+are given in units of 1/1000 of the scale factor (point size) of the font
+being used.
+"""
+
+from collections import namedtuple
+import logging
+import re
+
+from ._mathtext_data import uni2type1
+
+
+_log = logging.getLogger(__name__)
+
+
+def _to_int(x):
+ # Some AFM files have floats where we are expecting ints -- there is
+ # probably a better way to handle this (support floats, round rather than
+ # truncate). But I don't know what the best approach is now and this
+ # change to _to_int should at least prevent Matplotlib from crashing on
+ # these. JDH (2009-11-06)
+ return int(float(x))
+
+
+def _to_float(x):
+ # Some AFM files use "," instead of "." as decimal separator -- this
+ # shouldn't be ambiguous (unless someone is wicked enough to use "," as
+ # thousands separator...).
+ if isinstance(x, bytes):
+ # Encoding doesn't really matter -- if we have codepoints >127 the call
+ # to float() will error anyways.
+ x = x.decode('latin-1')
+ return float(x.replace(',', '.'))
+
+
+def _to_str(x):
+ return x.decode('utf8')
+
+
+def _to_list_of_ints(s):
+ s = s.replace(b',', b' ')
+ return [_to_int(val) for val in s.split()]
+
+
+def _to_list_of_floats(s):
+ return [_to_float(val) for val in s.split()]
+
+
+def _to_bool(s):
+ if s.lower().strip() in (b'false', b'0', b'no'):
+ return False
+ else:
+ return True
+
+
+def _parse_header(fh):
+ """
+ Read the font metrics header (up to the char metrics) and returns
+ a dictionary mapping *key* to *val*. *val* will be converted to the
+ appropriate python type as necessary; e.g.:
+
+ * 'False'->False
+ * '0'->0
+ * '-168 -218 1000 898'-> [-168, -218, 1000, 898]
+
+ Dictionary keys are
+
+ StartFontMetrics, FontName, FullName, FamilyName, Weight,
+ ItalicAngle, IsFixedPitch, FontBBox, UnderlinePosition,
+ UnderlineThickness, Version, Notice, EncodingScheme, CapHeight,
+ XHeight, Ascender, Descender, StartCharMetrics
+ """
+ header_converters = {
+ b'StartFontMetrics': _to_float,
+ b'FontName': _to_str,
+ b'FullName': _to_str,
+ b'FamilyName': _to_str,
+ b'Weight': _to_str,
+ b'ItalicAngle': _to_float,
+ b'IsFixedPitch': _to_bool,
+ b'FontBBox': _to_list_of_ints,
+ b'UnderlinePosition': _to_float,
+ b'UnderlineThickness': _to_float,
+ b'Version': _to_str,
+ # Some AFM files have non-ASCII characters (which are not allowed by
+ # the spec). Given that there is actually no public API to even access
+ # this field, just return it as straight bytes.
+ b'Notice': lambda x: x,
+ b'EncodingScheme': _to_str,
+ b'CapHeight': _to_float, # Is the second version a mistake, or
+ b'Capheight': _to_float, # do some AFM files contain 'Capheight'? -JKS
+ b'XHeight': _to_float,
+ b'Ascender': _to_float,
+ b'Descender': _to_float,
+ b'StdHW': _to_float,
+ b'StdVW': _to_float,
+ b'StartCharMetrics': _to_int,
+ b'CharacterSet': _to_str,
+ b'Characters': _to_int,
+ }
+ d = {}
+ first_line = True
+ for line in fh:
+ line = line.rstrip()
+ if line.startswith(b'Comment'):
+ continue
+ lst = line.split(b' ', 1)
+ key = lst[0]
+ if first_line:
+ # AFM spec, Section 4: The StartFontMetrics keyword
+ # [followed by a version number] must be the first line in
+ # the file, and the EndFontMetrics keyword must be the
+ # last non-empty line in the file. We just check the
+ # first header entry.
+ if key != b'StartFontMetrics':
+ raise RuntimeError('Not an AFM file')
+ first_line = False
+ if len(lst) == 2:
+ val = lst[1]
+ else:
+ val = b''
+ try:
+ converter = header_converters[key]
+ except KeyError:
+ _log.error("Found an unknown keyword in AFM header (was %r)", key)
+ continue
+ try:
+ d[key] = converter(val)
+ except ValueError:
+ _log.error('Value error parsing header in AFM: %s, %s', key, val)
+ continue
+ if key == b'StartCharMetrics':
+ break
+ else:
+ raise RuntimeError('Bad parse')
+ return d
+
+
+CharMetrics = namedtuple('CharMetrics', 'width, name, bbox')
+CharMetrics.__doc__ = """
+ Represents the character metrics of a single character.
+
+ Notes
+ -----
+ The fields do currently only describe a subset of character metrics
+ information defined in the AFM standard.
+ """
+CharMetrics.width.__doc__ = """The character width (WX)."""
+CharMetrics.name.__doc__ = """The character name (N)."""
+CharMetrics.bbox.__doc__ = """
+ The bbox of the character (B) as a tuple (*llx*, *lly*, *urx*, *ury*)."""
+
+
+def _parse_char_metrics(fh):
+ """
+ Parse the given filehandle for character metrics information and return
+ the information as dicts.
+
+ It is assumed that the file cursor is on the line behind
+ 'StartCharMetrics'.
+
+ Returns
+ -------
+ ascii_d : dict
+ A mapping "ASCII num of the character" to `.CharMetrics`.
+ name_d : dict
+ A mapping "character name" to `.CharMetrics`.
+
+ Notes
+ -----
+ This function is incomplete per the standard, but thus far parses
+ all the sample afm files tried.
+ """
+ required_keys = {'C', 'WX', 'N', 'B'}
+
+ ascii_d = {}
+ name_d = {}
+ for line in fh:
+ # We are defensively letting values be utf8. The spec requires
+ # ascii, but there are non-compliant fonts in circulation
+ line = _to_str(line.rstrip()) # Convert from byte-literal
+ if line.startswith('EndCharMetrics'):
+ return ascii_d, name_d
+ # Split the metric line into a dictionary, keyed by metric identifiers
+ vals = dict(s.strip().split(' ', 1) for s in line.split(';') if s)
+ # There may be other metrics present, but only these are needed
+ if not required_keys.issubset(vals):
+ raise RuntimeError('Bad char metrics line: %s' % line)
+ num = _to_int(vals['C'])
+ wx = _to_float(vals['WX'])
+ name = vals['N']
+ bbox = _to_list_of_floats(vals['B'])
+ bbox = list(map(int, bbox))
+ metrics = CharMetrics(wx, name, bbox)
+ # Workaround: If the character name is 'Euro', give it the
+ # corresponding character code, according to WinAnsiEncoding (see PDF
+ # Reference).
+ if name == 'Euro':
+ num = 128
+ elif name == 'minus':
+ num = ord("\N{MINUS SIGN}") # 0x2212
+ if num != -1:
+ ascii_d[num] = metrics
+ name_d[name] = metrics
+ raise RuntimeError('Bad parse')
+
+
+def _parse_kern_pairs(fh):
+ """
+ Return a kern pairs dictionary; keys are (*char1*, *char2*) tuples and
+ values are the kern pair value. For example, a kern pairs line like
+ ``KPX A y -50``
+
+ will be represented as::
+
+ d[ ('A', 'y') ] = -50
+
+ """
+
+ line = next(fh)
+ if not line.startswith(b'StartKernPairs'):
+ raise RuntimeError('Bad start of kern pairs data: %s' % line)
+
+ d = {}
+ for line in fh:
+ line = line.rstrip()
+ if not line:
+ continue
+ if line.startswith(b'EndKernPairs'):
+ next(fh) # EndKernData
+ return d
+ vals = line.split()
+ if len(vals) != 4 or vals[0] != b'KPX':
+ raise RuntimeError('Bad kern pairs line: %s' % line)
+ c1, c2, val = _to_str(vals[1]), _to_str(vals[2]), _to_float(vals[3])
+ d[(c1, c2)] = val
+ raise RuntimeError('Bad kern pairs parse')
+
+
+CompositePart = namedtuple('CompositePart', 'name, dx, dy')
+CompositePart.__doc__ = """
+ Represents the information on a composite element of a composite char."""
+CompositePart.name.__doc__ = """Name of the part, e.g. 'acute'."""
+CompositePart.dx.__doc__ = """x-displacement of the part from the origin."""
+CompositePart.dy.__doc__ = """y-displacement of the part from the origin."""
+
+
+def _parse_composites(fh):
+ """
+ Parse the given filehandle for composites information return them as a
+ dict.
+
+ It is assumed that the file cursor is on the line behind 'StartComposites'.
+
+ Returns
+ -------
+ dict
+ A dict mapping composite character names to a parts list. The parts
+ list is a list of `.CompositePart` entries describing the parts of
+ the composite.
+
+ Examples
+ --------
+ A composite definition line::
+
+ CC Aacute 2 ; PCC A 0 0 ; PCC acute 160 170 ;
+
+ will be represented as::
+
+ composites['Aacute'] = [CompositePart(name='A', dx=0, dy=0),
+ CompositePart(name='acute', dx=160, dy=170)]
+
+ """
+ composites = {}
+ for line in fh:
+ line = line.rstrip()
+ if not line:
+ continue
+ if line.startswith(b'EndComposites'):
+ return composites
+ vals = line.split(b';')
+ cc = vals[0].split()
+ name, _num_parts = cc[1], _to_int(cc[2])
+ pccParts = []
+ for s in vals[1:-1]:
+ pcc = s.split()
+ part = CompositePart(pcc[1], _to_float(pcc[2]), _to_float(pcc[3]))
+ pccParts.append(part)
+ composites[name] = pccParts
+
+ raise RuntimeError('Bad composites parse')
+
+
+def _parse_optional(fh):
+ """
+ Parse the optional fields for kern pair data and composites.
+
+ Returns
+ -------
+ kern_data : dict
+ A dict containing kerning information. May be empty.
+ See `._parse_kern_pairs`.
+ composites : dict
+ A dict containing composite information. May be empty.
+ See `._parse_composites`.
+ """
+ optional = {
+ b'StartKernData': _parse_kern_pairs,
+ b'StartComposites': _parse_composites,
+ }
+
+ d = {b'StartKernData': {},
+ b'StartComposites': {}}
+ for line in fh:
+ line = line.rstrip()
+ if not line:
+ continue
+ key = line.split()[0]
+
+ if key in optional:
+ d[key] = optional[key](fh)
+
+ return d[b'StartKernData'], d[b'StartComposites']
+
+
+class AFM:
+
+ def __init__(self, fh):
+ """Parse the AFM file in file object *fh*."""
+ self._header = _parse_header(fh)
+ self._metrics, self._metrics_by_name = _parse_char_metrics(fh)
+ self._kern, self._composite = _parse_optional(fh)
+
+ def get_bbox_char(self, c, isord=False):
+ if not isord:
+ c = ord(c)
+ return self._metrics[c].bbox
+
+ def string_width_height(self, s):
+ """
+ Return the string width (including kerning) and string height
+ as a (*w*, *h*) tuple.
+ """
+ if not len(s):
+ return 0, 0
+ total_width = 0
+ namelast = None
+ miny = 1e9
+ maxy = 0
+ for c in s:
+ if c == '\n':
+ continue
+ wx, name, bbox = self._metrics[ord(c)]
+
+ total_width += wx + self._kern.get((namelast, name), 0)
+ l, b, w, h = bbox
+ miny = min(miny, b)
+ maxy = max(maxy, b + h)
+
+ namelast = name
+
+ return total_width, maxy - miny
+
+ def get_str_bbox_and_descent(self, s):
+ """Return the string bounding box and the maximal descent."""
+ if not len(s):
+ return 0, 0, 0, 0, 0
+ total_width = 0
+ namelast = None
+ miny = 1e9
+ maxy = 0
+ left = 0
+ if not isinstance(s, str):
+ s = _to_str(s)
+ for c in s:
+ if c == '\n':
+ continue
+ name = uni2type1.get(ord(c), f"uni{ord(c):04X}")
+ try:
+ wx, _, bbox = self._metrics_by_name[name]
+ except KeyError:
+ name = 'question'
+ wx, _, bbox = self._metrics_by_name[name]
+ total_width += wx + self._kern.get((namelast, name), 0)
+ l, b, w, h = bbox
+ left = min(left, l)
+ miny = min(miny, b)
+ maxy = max(maxy, b + h)
+
+ namelast = name
+
+ return left, miny, total_width, maxy - miny, -miny
+
+ def get_str_bbox(self, s):
+ """Return the string bounding box."""
+ return self.get_str_bbox_and_descent(s)[:4]
+
+ def get_name_char(self, c, isord=False):
+ """Get the name of the character, i.e., ';' is 'semicolon'."""
+ if not isord:
+ c = ord(c)
+ return self._metrics[c].name
+
+ def get_width_char(self, c, isord=False):
+ """
+ Get the width of the character from the character metric WX field.
+ """
+ if not isord:
+ c = ord(c)
+ return self._metrics[c].width
+
+ def get_width_from_char_name(self, name):
+ """Get the width of the character from a type1 character name."""
+ return self._metrics_by_name[name].width
+
+ def get_height_char(self, c, isord=False):
+ """Get the bounding box (ink) height of character *c* (space is 0)."""
+ if not isord:
+ c = ord(c)
+ return self._metrics[c].bbox[-1]
+
+ def get_kern_dist(self, c1, c2):
+ """
+ Return the kerning pair distance (possibly 0) for chars *c1* and *c2*.
+ """
+ name1, name2 = self.get_name_char(c1), self.get_name_char(c2)
+ return self.get_kern_dist_from_name(name1, name2)
+
+ def get_kern_dist_from_name(self, name1, name2):
+ """
+ Return the kerning pair distance (possibly 0) for chars
+ *name1* and *name2*.
+ """
+ return self._kern.get((name1, name2), 0)
+
+ def get_fontname(self):
+ """Return the font name, e.g., 'Times-Roman'."""
+ return self._header[b'FontName']
+
+ @property
+ def postscript_name(self): # For consistency with FT2Font.
+ return self.get_fontname()
+
+ def get_fullname(self):
+ """Return the font full name, e.g., 'Times-Roman'."""
+ name = self._header.get(b'FullName')
+ if name is None: # use FontName as a substitute
+ name = self._header[b'FontName']
+ return name
+
+ def get_familyname(self):
+ """Return the font family name, e.g., 'Times'."""
+ name = self._header.get(b'FamilyName')
+ if name is not None:
+ return name
+
+ # FamilyName not specified so we'll make a guess
+ name = self.get_fullname()
+ extras = (r'(?i)([ -](regular|plain|italic|oblique|bold|semibold|'
+ r'light|ultralight|extra|condensed))+$')
+ return re.sub(extras, '', name)
+
+ @property
+ def family_name(self):
+ """The font family name, e.g., 'Times'."""
+ return self.get_familyname()
+
+ def get_weight(self):
+ """Return the font weight, e.g., 'Bold' or 'Roman'."""
+ return self._header[b'Weight']
+
+ def get_angle(self):
+ """Return the fontangle as float."""
+ return self._header[b'ItalicAngle']
+
+ def get_capheight(self):
+ """Return the cap height as float."""
+ return self._header[b'CapHeight']
+
+ def get_xheight(self):
+ """Return the xheight as float."""
+ return self._header[b'XHeight']
+
+ def get_underline_thickness(self):
+ """Return the underline thickness as float."""
+ return self._header[b'UnderlineThickness']
+
+ def get_horizontal_stem_width(self):
+ """
+ Return the standard horizontal stem width as float, or *None* if
+ not specified in AFM file.
+ """
+ return self._header.get(b'StdHW', None)
+
+ def get_vertical_stem_width(self):
+ """
+ Return the standard vertical stem width as float, or *None* if
+ not specified in AFM file.
+ """
+ return self._header.get(b'StdVW', None)
diff --git a/moondream/lib/python3.10/site-packages/matplotlib/_animation_data.py b/moondream/lib/python3.10/site-packages/matplotlib/_animation_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..8cbd312d8f142d8b4ec3a3ad3e005a14f380ec13
--- /dev/null
+++ b/moondream/lib/python3.10/site-packages/matplotlib/_animation_data.py
@@ -0,0 +1,262 @@
+# JavaScript template for HTMLWriter
+JS_INCLUDE = """
+
+
+"""
+
+
+# Style definitions for the HTML template
+STYLE_INCLUDE = """
+
+"""
+
+
+# HTML template for HTMLWriter
+DISPLAY_TEMPLATE = """
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+""" # noqa: E501
+
+
+INCLUDED_FRAMES = """
+ for (var i=0; i<{Nframes}; i++){{
+ frames[i] = "{frame_dir}/frame" + ("0000000" + i).slice(-7) +
+ ".{frame_format}";
+ }}
+"""
diff --git a/moondream/lib/python3.10/site-packages/matplotlib/_c_internal_utils.pyi b/moondream/lib/python3.10/site-packages/matplotlib/_c_internal_utils.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..ccc172cde27a35ad930cc618b86fdf5c8d44728e
--- /dev/null
+++ b/moondream/lib/python3.10/site-packages/matplotlib/_c_internal_utils.pyi
@@ -0,0 +1,8 @@
+def display_is_valid() -> bool: ...
+def xdisplay_is_valid() -> bool: ...
+
+def Win32_GetForegroundWindow() -> int | None: ...
+def Win32_SetForegroundWindow(hwnd: int) -> None: ...
+def Win32_SetProcessDpiAwareness_max() -> None: ...
+def Win32_SetCurrentProcessExplicitAppUserModelID(appid: str) -> None: ...
+def Win32_GetCurrentProcessExplicitAppUserModelID() -> str | None: ...
diff --git a/moondream/lib/python3.10/site-packages/matplotlib/_color_data.pyi b/moondream/lib/python3.10/site-packages/matplotlib/_color_data.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..feb3de9c3043d55910e2649804352ae96ccbd1ec
--- /dev/null
+++ b/moondream/lib/python3.10/site-packages/matplotlib/_color_data.pyi
@@ -0,0 +1,6 @@
+from .typing import ColorType
+
+BASE_COLORS: dict[str, ColorType]
+TABLEAU_COLORS: dict[str, ColorType]
+XKCD_COLORS: dict[str, ColorType]
+CSS4_COLORS: dict[str, ColorType]
diff --git a/moondream/lib/python3.10/site-packages/matplotlib/_constrained_layout.py b/moondream/lib/python3.10/site-packages/matplotlib/_constrained_layout.py
new file mode 100644
index 0000000000000000000000000000000000000000..5623e12a3c41d0d0d35041fd1dd9fb23e9938e51
--- /dev/null
+++ b/moondream/lib/python3.10/site-packages/matplotlib/_constrained_layout.py
@@ -0,0 +1,801 @@
+"""
+Adjust subplot layouts so that there are no overlapping Axes or Axes
+decorations. All Axes decorations are dealt with (labels, ticks, titles,
+ticklabels) and some dependent artists are also dealt with (colorbar,
+suptitle).
+
+Layout is done via `~matplotlib.gridspec`, with one constraint per gridspec,
+so it is possible to have overlapping Axes if the gridspecs overlap (i.e.
+using `~matplotlib.gridspec.GridSpecFromSubplotSpec`). Axes placed using
+``figure.subplots()`` or ``figure.add_subplots()`` will participate in the
+layout. Axes manually placed via ``figure.add_axes()`` will not.
+
+See Tutorial: :ref:`constrainedlayout_guide`
+
+General idea:
+-------------
+
+First, a figure has a gridspec that divides the figure into nrows and ncols,
+with heights and widths set by ``height_ratios`` and ``width_ratios``,
+often just set to 1 for an equal grid.
+
+Subplotspecs that are derived from this gridspec can contain either a
+``SubPanel``, a ``GridSpecFromSubplotSpec``, or an ``Axes``. The ``SubPanel``
+and ``GridSpecFromSubplotSpec`` are dealt with recursively and each contain an
+analogous layout.
+
+Each ``GridSpec`` has a ``_layoutgrid`` attached to it. The ``_layoutgrid``
+has the same logical layout as the ``GridSpec``. Each row of the grid spec
+has a top and bottom "margin" and each column has a left and right "margin".
+The "inner" height of each row is constrained to be the same (or as modified
+by ``height_ratio``), and the "inner" width of each column is
+constrained to be the same (as modified by ``width_ratio``), where "inner"
+is the width or height of each column/row minus the size of the margins.
+
+Then the size of the margins for each row and column are determined as the
+max width of the decorators on each Axes that has decorators in that margin.
+For instance, a normal Axes would have a left margin that includes the
+left ticklabels, and the ylabel if it exists. The right margin may include a
+colorbar, the bottom margin the xaxis decorations, and the top margin the
+title.
+
+With these constraints, the solver then finds appropriate bounds for the
+columns and rows. It's possible that the margins take up the whole figure,
+in which case the algorithm is not applied and a warning is raised.
+
+See the tutorial :ref:`constrainedlayout_guide`
+for more discussion of the algorithm with examples.
+"""
+
+import logging
+
+import numpy as np
+
+from matplotlib import _api, artist as martist
+import matplotlib.transforms as mtransforms
+import matplotlib._layoutgrid as mlayoutgrid
+
+
+_log = logging.getLogger(__name__)
+
+
+######################################################
+def do_constrained_layout(fig, h_pad, w_pad,
+ hspace=None, wspace=None, rect=(0, 0, 1, 1),
+ compress=False):
+ """
+ Do the constrained_layout. Called at draw time in
+ ``figure.constrained_layout()``
+
+ Parameters
+ ----------
+ fig : `~matplotlib.figure.Figure`
+ `.Figure` instance to do the layout in.
+
+ h_pad, w_pad : float
+ Padding around the Axes elements in figure-normalized units.
+
+ hspace, wspace : float
+ Fraction of the figure to dedicate to space between the
+ Axes. These are evenly spread between the gaps between the Axes.
+ A value of 0.2 for a three-column layout would have a space
+ of 0.1 of the figure width between each column.
+ If h/wspace < h/w_pad, then the pads are used instead.
+
+ rect : tuple of 4 floats
+ Rectangle in figure coordinates to perform constrained layout in
+ [left, bottom, width, height], each from 0-1.
+
+ compress : bool
+ Whether to shift Axes so that white space in between them is
+ removed. This is useful for simple grids of fixed-aspect Axes (e.g.
+ a grid of images).
+
+ Returns
+ -------
+ layoutgrid : private debugging structure
+ """
+
+ renderer = fig._get_renderer()
+ # make layoutgrid tree...
+ layoutgrids = make_layoutgrids(fig, None, rect=rect)
+ if not layoutgrids['hasgrids']:
+ _api.warn_external('There are no gridspecs with layoutgrids. '
+ 'Possibly did not call parent GridSpec with the'
+ ' "figure" keyword')
+ return
+
+ for _ in range(2):
+ # do the algorithm twice. This has to be done because decorations
+ # change size after the first re-position (i.e. x/yticklabels get
+ # larger/smaller). This second reposition tends to be much milder,
+ # so doing twice makes things work OK.
+
+ # make margins for all the Axes and subfigures in the
+ # figure. Add margins for colorbars...
+ make_layout_margins(layoutgrids, fig, renderer, h_pad=h_pad,
+ w_pad=w_pad, hspace=hspace, wspace=wspace)
+ make_margin_suptitles(layoutgrids, fig, renderer, h_pad=h_pad,
+ w_pad=w_pad)
+
+ # if a layout is such that a columns (or rows) margin has no
+ # constraints, we need to make all such instances in the grid
+ # match in margin size.
+ match_submerged_margins(layoutgrids, fig)
+
+ # update all the variables in the layout.
+ layoutgrids[fig].update_variables()
+
+ warn_collapsed = ('constrained_layout not applied because '
+ 'axes sizes collapsed to zero. Try making '
+ 'figure larger or Axes decorations smaller.')
+ if check_no_collapsed_axes(layoutgrids, fig):
+ reposition_axes(layoutgrids, fig, renderer, h_pad=h_pad,
+ w_pad=w_pad, hspace=hspace, wspace=wspace)
+ if compress:
+ layoutgrids = compress_fixed_aspect(layoutgrids, fig)
+ layoutgrids[fig].update_variables()
+ if check_no_collapsed_axes(layoutgrids, fig):
+ reposition_axes(layoutgrids, fig, renderer, h_pad=h_pad,
+ w_pad=w_pad, hspace=hspace, wspace=wspace)
+ else:
+ _api.warn_external(warn_collapsed)
+
+ if ((suptitle := fig._suptitle) is not None and
+ suptitle.get_in_layout() and suptitle._autopos):
+ x, _ = suptitle.get_position()
+ suptitle.set_position(
+ (x, layoutgrids[fig].get_inner_bbox().y1 + h_pad))
+ suptitle.set_verticalalignment('bottom')
+ else:
+ _api.warn_external(warn_collapsed)
+ reset_margins(layoutgrids, fig)
+ return layoutgrids
+
+
+def make_layoutgrids(fig, layoutgrids, rect=(0, 0, 1, 1)):
+ """
+ Make the layoutgrid tree.
+
+ (Sub)Figures get a layoutgrid so we can have figure margins.
+
+ Gridspecs that are attached to Axes get a layoutgrid so Axes
+ can have margins.
+ """
+
+ if layoutgrids is None:
+ layoutgrids = dict()
+ layoutgrids['hasgrids'] = False
+ if not hasattr(fig, '_parent'):
+ # top figure; pass rect as parent to allow user-specified
+ # margins
+ layoutgrids[fig] = mlayoutgrid.LayoutGrid(parent=rect, name='figlb')
+ else:
+ # subfigure
+ gs = fig._subplotspec.get_gridspec()
+ # it is possible the gridspec containing this subfigure hasn't
+ # been added to the tree yet:
+ layoutgrids = make_layoutgrids_gs(layoutgrids, gs)
+ # add the layoutgrid for the subfigure:
+ parentlb = layoutgrids[gs]
+ layoutgrids[fig] = mlayoutgrid.LayoutGrid(
+ parent=parentlb,
+ name='panellb',
+ parent_inner=True,
+ nrows=1, ncols=1,
+ parent_pos=(fig._subplotspec.rowspan,
+ fig._subplotspec.colspan))
+ # recursively do all subfigures in this figure...
+ for sfig in fig.subfigs:
+ layoutgrids = make_layoutgrids(sfig, layoutgrids)
+
+ # for each Axes at the local level add its gridspec:
+ for ax in fig._localaxes:
+ gs = ax.get_gridspec()
+ if gs is not None:
+ layoutgrids = make_layoutgrids_gs(layoutgrids, gs)
+
+ return layoutgrids
+
+
+def make_layoutgrids_gs(layoutgrids, gs):
+ """
+ Make the layoutgrid for a gridspec (and anything nested in the gridspec)
+ """
+
+ if gs in layoutgrids or gs.figure is None:
+ return layoutgrids
+ # in order to do constrained_layout there has to be at least *one*
+ # gridspec in the tree:
+ layoutgrids['hasgrids'] = True
+ if not hasattr(gs, '_subplot_spec'):
+ # normal gridspec
+ parent = layoutgrids[gs.figure]
+ layoutgrids[gs] = mlayoutgrid.LayoutGrid(
+ parent=parent,
+ parent_inner=True,
+ name='gridspec',
+ ncols=gs._ncols, nrows=gs._nrows,
+ width_ratios=gs.get_width_ratios(),
+ height_ratios=gs.get_height_ratios())
+ else:
+ # this is a gridspecfromsubplotspec:
+ subplot_spec = gs._subplot_spec
+ parentgs = subplot_spec.get_gridspec()
+ # if a nested gridspec it is possible the parent is not in there yet:
+ if parentgs not in layoutgrids:
+ layoutgrids = make_layoutgrids_gs(layoutgrids, parentgs)
+ subspeclb = layoutgrids[parentgs]
+ # gridspecfromsubplotspec need an outer container:
+ # get a unique representation:
+ rep = (gs, 'top')
+ if rep not in layoutgrids:
+ layoutgrids[rep] = mlayoutgrid.LayoutGrid(
+ parent=subspeclb,
+ name='top',
+ nrows=1, ncols=1,
+ parent_pos=(subplot_spec.rowspan, subplot_spec.colspan))
+ layoutgrids[gs] = mlayoutgrid.LayoutGrid(
+ parent=layoutgrids[rep],
+ name='gridspec',
+ nrows=gs._nrows, ncols=gs._ncols,
+ width_ratios=gs.get_width_ratios(),
+ height_ratios=gs.get_height_ratios())
+ return layoutgrids
+
+
+def check_no_collapsed_axes(layoutgrids, fig):
+ """
+ Check that no Axes have collapsed to zero size.
+ """
+ for sfig in fig.subfigs:
+ ok = check_no_collapsed_axes(layoutgrids, sfig)
+ if not ok:
+ return False
+ for ax in fig.axes:
+ gs = ax.get_gridspec()
+ if gs in layoutgrids: # also implies gs is not None.
+ lg = layoutgrids[gs]
+ for i in range(gs.nrows):
+ for j in range(gs.ncols):
+ bb = lg.get_inner_bbox(i, j)
+ if bb.width <= 0 or bb.height <= 0:
+ return False
+ return True
+
+
+def compress_fixed_aspect(layoutgrids, fig):
+ gs = None
+ for ax in fig.axes:
+ if ax.get_subplotspec() is None:
+ continue
+ ax.apply_aspect()
+ sub = ax.get_subplotspec()
+ _gs = sub.get_gridspec()
+ if gs is None:
+ gs = _gs
+ extraw = np.zeros(gs.ncols)
+ extrah = np.zeros(gs.nrows)
+ elif _gs != gs:
+ raise ValueError('Cannot do compressed layout if Axes are not'
+ 'all from the same gridspec')
+ orig = ax.get_position(original=True)
+ actual = ax.get_position(original=False)
+ dw = orig.width - actual.width
+ if dw > 0:
+ extraw[sub.colspan] = np.maximum(extraw[sub.colspan], dw)
+ dh = orig.height - actual.height
+ if dh > 0:
+ extrah[sub.rowspan] = np.maximum(extrah[sub.rowspan], dh)
+
+ if gs is None:
+ raise ValueError('Cannot do compressed layout if no Axes '
+ 'are part of a gridspec.')
+ w = np.sum(extraw) / 2
+ layoutgrids[fig].edit_margin_min('left', w)
+ layoutgrids[fig].edit_margin_min('right', w)
+
+ h = np.sum(extrah) / 2
+ layoutgrids[fig].edit_margin_min('top', h)
+ layoutgrids[fig].edit_margin_min('bottom', h)
+ return layoutgrids
+
+
+def get_margin_from_padding(obj, *, w_pad=0, h_pad=0,
+ hspace=0, wspace=0):
+
+ ss = obj._subplotspec
+ gs = ss.get_gridspec()
+
+ if hasattr(gs, 'hspace'):
+ _hspace = (gs.hspace if gs.hspace is not None else hspace)
+ _wspace = (gs.wspace if gs.wspace is not None else wspace)
+ else:
+ _hspace = (gs._hspace if gs._hspace is not None else hspace)
+ _wspace = (gs._wspace if gs._wspace is not None else wspace)
+
+ _wspace = _wspace / 2
+ _hspace = _hspace / 2
+
+ nrows, ncols = gs.get_geometry()
+ # there are two margins for each direction. The "cb"
+ # margins are for pads and colorbars, the non-"cb" are
+ # for the Axes decorations (labels etc).
+ margin = {'leftcb': w_pad, 'rightcb': w_pad,
+ 'bottomcb': h_pad, 'topcb': h_pad,
+ 'left': 0, 'right': 0,
+ 'top': 0, 'bottom': 0}
+ if _wspace / ncols > w_pad:
+ if ss.colspan.start > 0:
+ margin['leftcb'] = _wspace / ncols
+ if ss.colspan.stop < ncols:
+ margin['rightcb'] = _wspace / ncols
+ if _hspace / nrows > h_pad:
+ if ss.rowspan.stop < nrows:
+ margin['bottomcb'] = _hspace / nrows
+ if ss.rowspan.start > 0:
+ margin['topcb'] = _hspace / nrows
+
+ return margin
+
+
+def make_layout_margins(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0,
+ hspace=0, wspace=0):
+ """
+ For each Axes, make a margin between the *pos* layoutbox and the
+ *axes* layoutbox be a minimum size that can accommodate the
+ decorations on the axis.
+
+ Then make room for colorbars.
+
+ Parameters
+ ----------
+ layoutgrids : dict
+ fig : `~matplotlib.figure.Figure`
+ `.Figure` instance to do the layout in.
+ renderer : `~matplotlib.backend_bases.RendererBase` subclass.
+ The renderer to use.
+ w_pad, h_pad : float, default: 0
+ Width and height padding (in fraction of figure).
+ hspace, wspace : float, default: 0
+ Width and height padding as fraction of figure size divided by
+ number of columns or rows.
+ """
+ for sfig in fig.subfigs: # recursively make child panel margins
+ ss = sfig._subplotspec
+ gs = ss.get_gridspec()
+
+ make_layout_margins(layoutgrids, sfig, renderer,
+ w_pad=w_pad, h_pad=h_pad,
+ hspace=hspace, wspace=wspace)
+
+ margins = get_margin_from_padding(sfig, w_pad=0, h_pad=0,
+ hspace=hspace, wspace=wspace)
+ layoutgrids[gs].edit_outer_margin_mins(margins, ss)
+
+ for ax in fig._localaxes:
+ if not ax.get_subplotspec() or not ax.get_in_layout():
+ continue
+
+ ss = ax.get_subplotspec()
+ gs = ss.get_gridspec()
+
+ if gs not in layoutgrids:
+ return
+
+ margin = get_margin_from_padding(ax, w_pad=w_pad, h_pad=h_pad,
+ hspace=hspace, wspace=wspace)
+ pos, bbox = get_pos_and_bbox(ax, renderer)
+ # the margin is the distance between the bounding box of the Axes
+ # and its position (plus the padding from above)
+ margin['left'] += pos.x0 - bbox.x0
+ margin['right'] += bbox.x1 - pos.x1
+ # remember that rows are ordered from top:
+ margin['bottom'] += pos.y0 - bbox.y0
+ margin['top'] += bbox.y1 - pos.y1
+
+ # make margin for colorbars. These margins go in the
+ # padding margin, versus the margin for Axes decorators.
+ for cbax in ax._colorbars:
+ # note pad is a fraction of the parent width...
+ pad = colorbar_get_pad(layoutgrids, cbax)
+ # colorbars can be child of more than one subplot spec:
+ cbp_rspan, cbp_cspan = get_cb_parent_spans(cbax)
+ loc = cbax._colorbar_info['location']
+ cbpos, cbbbox = get_pos_and_bbox(cbax, renderer)
+ if loc == 'right':
+ if cbp_cspan.stop == ss.colspan.stop:
+ # only increase if the colorbar is on the right edge
+ margin['rightcb'] += cbbbox.width + pad
+ elif loc == 'left':
+ if cbp_cspan.start == ss.colspan.start:
+ # only increase if the colorbar is on the left edge
+ margin['leftcb'] += cbbbox.width + pad
+ elif loc == 'top':
+ if cbp_rspan.start == ss.rowspan.start:
+ margin['topcb'] += cbbbox.height + pad
+ else:
+ if cbp_rspan.stop == ss.rowspan.stop:
+ margin['bottomcb'] += cbbbox.height + pad
+ # If the colorbars are wider than the parent box in the
+ # cross direction
+ if loc in ['top', 'bottom']:
+ if (cbp_cspan.start == ss.colspan.start and
+ cbbbox.x0 < bbox.x0):
+ margin['left'] += bbox.x0 - cbbbox.x0
+ if (cbp_cspan.stop == ss.colspan.stop and
+ cbbbox.x1 > bbox.x1):
+ margin['right'] += cbbbox.x1 - bbox.x1
+ # or taller:
+ if loc in ['left', 'right']:
+ if (cbp_rspan.stop == ss.rowspan.stop and
+ cbbbox.y0 < bbox.y0):
+ margin['bottom'] += bbox.y0 - cbbbox.y0
+ if (cbp_rspan.start == ss.rowspan.start and
+ cbbbox.y1 > bbox.y1):
+ margin['top'] += cbbbox.y1 - bbox.y1
+ # pass the new margins down to the layout grid for the solution...
+ layoutgrids[gs].edit_outer_margin_mins(margin, ss)
+
+ # make margins for figure-level legends:
+ for leg in fig.legends:
+ inv_trans_fig = None
+ if leg._outside_loc and leg._bbox_to_anchor is None:
+ if inv_trans_fig is None:
+ inv_trans_fig = fig.transFigure.inverted().transform_bbox
+ bbox = inv_trans_fig(leg.get_tightbbox(renderer))
+ w = bbox.width + 2 * w_pad
+ h = bbox.height + 2 * h_pad
+ legendloc = leg._outside_loc
+ if legendloc == 'lower':
+ layoutgrids[fig].edit_margin_min('bottom', h)
+ elif legendloc == 'upper':
+ layoutgrids[fig].edit_margin_min('top', h)
+ if legendloc == 'right':
+ layoutgrids[fig].edit_margin_min('right', w)
+ elif legendloc == 'left':
+ layoutgrids[fig].edit_margin_min('left', w)
+
+
+def make_margin_suptitles(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0):
+ # Figure out how large the suptitle is and make the
+ # top level figure margin larger.
+
+ inv_trans_fig = fig.transFigure.inverted().transform_bbox
+ # get the h_pad and w_pad as distances in the local subfigure coordinates:
+ padbox = mtransforms.Bbox([[0, 0], [w_pad, h_pad]])
+ padbox = (fig.transFigure -
+ fig.transSubfigure).transform_bbox(padbox)
+ h_pad_local = padbox.height
+ w_pad_local = padbox.width
+
+ for sfig in fig.subfigs:
+ make_margin_suptitles(layoutgrids, sfig, renderer,
+ w_pad=w_pad, h_pad=h_pad)
+
+ if fig._suptitle is not None and fig._suptitle.get_in_layout():
+ p = fig._suptitle.get_position()
+ if getattr(fig._suptitle, '_autopos', False):
+ fig._suptitle.set_position((p[0], 1 - h_pad_local))
+ bbox = inv_trans_fig(fig._suptitle.get_tightbbox(renderer))
+ layoutgrids[fig].edit_margin_min('top', bbox.height + 2 * h_pad)
+
+ if fig._supxlabel is not None and fig._supxlabel.get_in_layout():
+ p = fig._supxlabel.get_position()
+ if getattr(fig._supxlabel, '_autopos', False):
+ fig._supxlabel.set_position((p[0], h_pad_local))
+ bbox = inv_trans_fig(fig._supxlabel.get_tightbbox(renderer))
+ layoutgrids[fig].edit_margin_min('bottom',
+ bbox.height + 2 * h_pad)
+
+ if fig._supylabel is not None and fig._supylabel.get_in_layout():
+ p = fig._supylabel.get_position()
+ if getattr(fig._supylabel, '_autopos', False):
+ fig._supylabel.set_position((w_pad_local, p[1]))
+ bbox = inv_trans_fig(fig._supylabel.get_tightbbox(renderer))
+ layoutgrids[fig].edit_margin_min('left', bbox.width + 2 * w_pad)
+
+
+def match_submerged_margins(layoutgrids, fig):
+ """
+ Make the margins that are submerged inside an Axes the same size.
+
+ This allows Axes that span two columns (or rows) that are offset
+ from one another to have the same size.
+
+ This gives the proper layout for something like::
+ fig = plt.figure(constrained_layout=True)
+ axs = fig.subplot_mosaic("AAAB\nCCDD")
+
+ Without this routine, the Axes D will be wider than C, because the
+ margin width between the two columns in C has no width by default,
+ whereas the margins between the two columns of D are set by the
+ width of the margin between A and B. However, obviously the user would
+ like C and D to be the same size, so we need to add constraints to these
+ "submerged" margins.
+
+ This routine makes all the interior margins the same, and the spacing
+ between the three columns in A and the two column in C are all set to the
+ margins between the two columns of D.
+
+ See test_constrained_layout::test_constrained_layout12 for an example.
+ """
+
+ for sfig in fig.subfigs:
+ match_submerged_margins(layoutgrids, sfig)
+
+ axs = [a for a in fig.get_axes()
+ if a.get_subplotspec() is not None and a.get_in_layout()]
+
+ for ax1 in axs:
+ ss1 = ax1.get_subplotspec()
+ if ss1.get_gridspec() not in layoutgrids:
+ axs.remove(ax1)
+ continue
+ lg1 = layoutgrids[ss1.get_gridspec()]
+
+ # interior columns:
+ if len(ss1.colspan) > 1:
+ maxsubl = np.max(
+ lg1.margin_vals['left'][ss1.colspan[1:]] +
+ lg1.margin_vals['leftcb'][ss1.colspan[1:]]
+ )
+ maxsubr = np.max(
+ lg1.margin_vals['right'][ss1.colspan[:-1]] +
+ lg1.margin_vals['rightcb'][ss1.colspan[:-1]]
+ )
+ for ax2 in axs:
+ ss2 = ax2.get_subplotspec()
+ lg2 = layoutgrids[ss2.get_gridspec()]
+ if lg2 is not None and len(ss2.colspan) > 1:
+ maxsubl2 = np.max(
+ lg2.margin_vals['left'][ss2.colspan[1:]] +
+ lg2.margin_vals['leftcb'][ss2.colspan[1:]])
+ if maxsubl2 > maxsubl:
+ maxsubl = maxsubl2
+ maxsubr2 = np.max(
+ lg2.margin_vals['right'][ss2.colspan[:-1]] +
+ lg2.margin_vals['rightcb'][ss2.colspan[:-1]])
+ if maxsubr2 > maxsubr:
+ maxsubr = maxsubr2
+ for i in ss1.colspan[1:]:
+ lg1.edit_margin_min('left', maxsubl, cell=i)
+ for i in ss1.colspan[:-1]:
+ lg1.edit_margin_min('right', maxsubr, cell=i)
+
+ # interior rows:
+ if len(ss1.rowspan) > 1:
+ maxsubt = np.max(
+ lg1.margin_vals['top'][ss1.rowspan[1:]] +
+ lg1.margin_vals['topcb'][ss1.rowspan[1:]]
+ )
+ maxsubb = np.max(
+ lg1.margin_vals['bottom'][ss1.rowspan[:-1]] +
+ lg1.margin_vals['bottomcb'][ss1.rowspan[:-1]]
+ )
+
+ for ax2 in axs:
+ ss2 = ax2.get_subplotspec()
+ lg2 = layoutgrids[ss2.get_gridspec()]
+ if lg2 is not None:
+ if len(ss2.rowspan) > 1:
+ maxsubt = np.max([np.max(
+ lg2.margin_vals['top'][ss2.rowspan[1:]] +
+ lg2.margin_vals['topcb'][ss2.rowspan[1:]]
+ ), maxsubt])
+ maxsubb = np.max([np.max(
+ lg2.margin_vals['bottom'][ss2.rowspan[:-1]] +
+ lg2.margin_vals['bottomcb'][ss2.rowspan[:-1]]
+ ), maxsubb])
+ for i in ss1.rowspan[1:]:
+ lg1.edit_margin_min('top', maxsubt, cell=i)
+ for i in ss1.rowspan[:-1]:
+ lg1.edit_margin_min('bottom', maxsubb, cell=i)
+
+
+def get_cb_parent_spans(cbax):
+ """
+ Figure out which subplotspecs this colorbar belongs to.
+
+ Parameters
+ ----------
+ cbax : `~matplotlib.axes.Axes`
+ Axes for the colorbar.
+ """
+ rowstart = np.inf
+ rowstop = -np.inf
+ colstart = np.inf
+ colstop = -np.inf
+ for parent in cbax._colorbar_info['parents']:
+ ss = parent.get_subplotspec()
+ rowstart = min(ss.rowspan.start, rowstart)
+ rowstop = max(ss.rowspan.stop, rowstop)
+ colstart = min(ss.colspan.start, colstart)
+ colstop = max(ss.colspan.stop, colstop)
+
+ rowspan = range(rowstart, rowstop)
+ colspan = range(colstart, colstop)
+ return rowspan, colspan
+
+
+def get_pos_and_bbox(ax, renderer):
+ """
+ Get the position and the bbox for the Axes.
+
+ Parameters
+ ----------
+ ax : `~matplotlib.axes.Axes`
+ renderer : `~matplotlib.backend_bases.RendererBase` subclass.
+
+ Returns
+ -------
+ pos : `~matplotlib.transforms.Bbox`
+ Position in figure coordinates.
+ bbox : `~matplotlib.transforms.Bbox`
+ Tight bounding box in figure coordinates.
+ """
+ fig = ax.get_figure(root=False)
+ pos = ax.get_position(original=True)
+ # pos is in panel co-ords, but we need in figure for the layout
+ pos = pos.transformed(fig.transSubfigure - fig.transFigure)
+ tightbbox = martist._get_tightbbox_for_layout_only(ax, renderer)
+ if tightbbox is None:
+ bbox = pos
+ else:
+ bbox = tightbbox.transformed(fig.transFigure.inverted())
+ return pos, bbox
+
+
+def reposition_axes(layoutgrids, fig, renderer, *,
+ w_pad=0, h_pad=0, hspace=0, wspace=0):
+ """
+ Reposition all the Axes based on the new inner bounding box.
+ """
+ trans_fig_to_subfig = fig.transFigure - fig.transSubfigure
+ for sfig in fig.subfigs:
+ bbox = layoutgrids[sfig].get_outer_bbox()
+ sfig._redo_transform_rel_fig(
+ bbox=bbox.transformed(trans_fig_to_subfig))
+ reposition_axes(layoutgrids, sfig, renderer,
+ w_pad=w_pad, h_pad=h_pad,
+ wspace=wspace, hspace=hspace)
+
+ for ax in fig._localaxes:
+ if ax.get_subplotspec() is None or not ax.get_in_layout():
+ continue
+
+ # grid bbox is in Figure coordinates, but we specify in panel
+ # coordinates...
+ ss = ax.get_subplotspec()
+ gs = ss.get_gridspec()
+ if gs not in layoutgrids:
+ return
+
+ bbox = layoutgrids[gs].get_inner_bbox(rows=ss.rowspan,
+ cols=ss.colspan)
+
+ # transform from figure to panel for set_position:
+ newbbox = trans_fig_to_subfig.transform_bbox(bbox)
+ ax._set_position(newbbox)
+
+ # move the colorbars:
+ # we need to keep track of oldw and oldh if there is more than
+ # one colorbar:
+ offset = {'left': 0, 'right': 0, 'bottom': 0, 'top': 0}
+ for nn, cbax in enumerate(ax._colorbars[::-1]):
+ if ax == cbax._colorbar_info['parents'][0]:
+ reposition_colorbar(layoutgrids, cbax, renderer,
+ offset=offset)
+
+
+def reposition_colorbar(layoutgrids, cbax, renderer, *, offset=None):
+ """
+ Place the colorbar in its new place.
+
+ Parameters
+ ----------
+ layoutgrids : dict
+ cbax : `~matplotlib.axes.Axes`
+ Axes for the colorbar.
+ renderer : `~matplotlib.backend_bases.RendererBase` subclass.
+ The renderer to use.
+ offset : array-like
+ Offset the colorbar needs to be pushed to in order to
+ account for multiple colorbars.
+ """
+
+ parents = cbax._colorbar_info['parents']
+ gs = parents[0].get_gridspec()
+ fig = cbax.get_figure(root=False)
+ trans_fig_to_subfig = fig.transFigure - fig.transSubfigure
+
+ cb_rspans, cb_cspans = get_cb_parent_spans(cbax)
+ bboxparent = layoutgrids[gs].get_bbox_for_cb(rows=cb_rspans,
+ cols=cb_cspans)
+ pb = layoutgrids[gs].get_inner_bbox(rows=cb_rspans, cols=cb_cspans)
+
+ location = cbax._colorbar_info['location']
+ anchor = cbax._colorbar_info['anchor']
+ fraction = cbax._colorbar_info['fraction']
+ aspect = cbax._colorbar_info['aspect']
+ shrink = cbax._colorbar_info['shrink']
+
+ cbpos, cbbbox = get_pos_and_bbox(cbax, renderer)
+
+ # Colorbar gets put at extreme edge of outer bbox of the subplotspec
+ # It needs to be moved in by: 1) a pad 2) its "margin" 3) by
+ # any colorbars already added at this location:
+ cbpad = colorbar_get_pad(layoutgrids, cbax)
+ if location in ('left', 'right'):
+ # fraction and shrink are fractions of parent
+ pbcb = pb.shrunk(fraction, shrink).anchored(anchor, pb)
+ # The colorbar is at the left side of the parent. Need
+ # to translate to right (or left)
+ if location == 'right':
+ lmargin = cbpos.x0 - cbbbox.x0
+ dx = bboxparent.x1 - pbcb.x0 + offset['right']
+ dx += cbpad + lmargin
+ offset['right'] += cbbbox.width + cbpad
+ pbcb = pbcb.translated(dx, 0)
+ else:
+ lmargin = cbpos.x0 - cbbbox.x0
+ dx = bboxparent.x0 - pbcb.x0 # edge of parent
+ dx += -cbbbox.width - cbpad + lmargin - offset['left']
+ offset['left'] += cbbbox.width + cbpad
+ pbcb = pbcb.translated(dx, 0)
+ else: # horizontal axes:
+ pbcb = pb.shrunk(shrink, fraction).anchored(anchor, pb)
+ if location == 'top':
+ bmargin = cbpos.y0 - cbbbox.y0
+ dy = bboxparent.y1 - pbcb.y0 + offset['top']
+ dy += cbpad + bmargin
+ offset['top'] += cbbbox.height + cbpad
+ pbcb = pbcb.translated(0, dy)
+ else:
+ bmargin = cbpos.y0 - cbbbox.y0
+ dy = bboxparent.y0 - pbcb.y0
+ dy += -cbbbox.height - cbpad + bmargin - offset['bottom']
+ offset['bottom'] += cbbbox.height + cbpad
+ pbcb = pbcb.translated(0, dy)
+
+ pbcb = trans_fig_to_subfig.transform_bbox(pbcb)
+ cbax.set_transform(fig.transSubfigure)
+ cbax._set_position(pbcb)
+ cbax.set_anchor(anchor)
+ if location in ['bottom', 'top']:
+ aspect = 1 / aspect
+ cbax.set_box_aspect(aspect)
+ cbax.set_aspect('auto')
+ return offset
+
+
+def reset_margins(layoutgrids, fig):
+ """
+ Reset the margins in the layoutboxes of *fig*.
+
+ Margins are usually set as a minimum, so if the figure gets smaller
+ the minimum needs to be zero in order for it to grow again.
+ """
+ for sfig in fig.subfigs:
+ reset_margins(layoutgrids, sfig)
+ for ax in fig.axes:
+ if ax.get_in_layout():
+ gs = ax.get_gridspec()
+ if gs in layoutgrids: # also implies gs is not None.
+ layoutgrids[gs].reset_margins()
+ layoutgrids[fig].reset_margins()
+
+
+def colorbar_get_pad(layoutgrids, cax):
+ parents = cax._colorbar_info['parents']
+ gs = parents[0].get_gridspec()
+
+ cb_rspans, cb_cspans = get_cb_parent_spans(cax)
+ bboxouter = layoutgrids[gs].get_inner_bbox(rows=cb_rspans, cols=cb_cspans)
+
+ if cax._colorbar_info['location'] in ['right', 'left']:
+ size = bboxouter.width
+ else:
+ size = bboxouter.height
+
+ return cax._colorbar_info['pad'] * size
diff --git a/moondream/lib/python3.10/site-packages/matplotlib/_docstring.pyi b/moondream/lib/python3.10/site-packages/matplotlib/_docstring.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..fb52d084612399f399e6bcd3f07bca85bb010ba0
--- /dev/null
+++ b/moondream/lib/python3.10/site-packages/matplotlib/_docstring.pyi
@@ -0,0 +1,34 @@
+from collections.abc import Callable
+from typing import Any, TypeVar, overload
+
+
+_T = TypeVar('_T')
+
+
+def kwarg_doc(text: str) -> Callable[[_T], _T]: ...
+
+
+class Substitution:
+ @overload
+ def __init__(self, *args: str): ...
+ @overload
+ def __init__(self, **kwargs: str): ...
+ def __call__(self, func: _T) -> _T: ...
+ def update(self, *args, **kwargs): ... # type: ignore[no-untyped-def]
+
+
+class _ArtistKwdocLoader(dict[str, str]):
+ def __missing__(self, key: str) -> str: ...
+
+
+class _ArtistPropertiesSubstitution:
+ def __init__(self) -> None: ...
+ def register(self, **kwargs) -> None: ...
+ def __call__(self, obj: _T) -> _T: ...
+
+
+def copy(source: Any) -> Callable[[_T], _T]: ...
+
+
+dedent_interpd: _ArtistPropertiesSubstitution
+interpd: _ArtistPropertiesSubstitution
diff --git a/moondream/lib/python3.10/site-packages/matplotlib/_enums.py b/moondream/lib/python3.10/site-packages/matplotlib/_enums.py
new file mode 100644
index 0000000000000000000000000000000000000000..773011d36bf6f17d0dba073eef6db95924a3d11c
--- /dev/null
+++ b/moondream/lib/python3.10/site-packages/matplotlib/_enums.py
@@ -0,0 +1,187 @@
+"""
+Enums representing sets of strings that Matplotlib uses as input parameters.
+
+Matplotlib often uses simple data types like strings or tuples to define a
+concept; e.g. the line capstyle can be specified as one of 'butt', 'round',
+or 'projecting'. The classes in this module are used internally and serve to
+document these concepts formally.
+
+As an end-user you will not use these classes directly, but only the values
+they define.
+"""
+
+from enum import Enum, auto
+from matplotlib import _docstring
+
+
+class _AutoStringNameEnum(Enum):
+ """Automate the ``name = 'name'`` part of making a (str, Enum)."""
+
+ def _generate_next_value_(name, start, count, last_values):
+ return name
+
+ def __hash__(self):
+ return str(self).__hash__()
+
+
+class JoinStyle(str, _AutoStringNameEnum):
+ """
+ Define how the connection between two line segments is drawn.
+
+ For a visual impression of each *JoinStyle*, `view these docs online
+ `, or run `JoinStyle.demo`.
+
+ Lines in Matplotlib are typically defined by a 1D `~.path.Path` and a
+ finite ``linewidth``, where the underlying 1D `~.path.Path` represents the
+ center of the stroked line.
+
+ By default, `~.backend_bases.GraphicsContextBase` defines the boundaries of
+ a stroked line to simply be every point within some radius,
+ ``linewidth/2``, away from any point of the center line. However, this
+ results in corners appearing "rounded", which may not be the desired
+ behavior if you are drawing, for example, a polygon or pointed star.
+
+ **Supported values:**
+
+ .. rst-class:: value-list
+
+ 'miter'
+ the "arrow-tip" style. Each boundary of the filled-in area will
+ extend in a straight line parallel to the tangent vector of the
+ centerline at the point it meets the corner, until they meet in a
+ sharp point.
+ 'round'
+ stokes every point within a radius of ``linewidth/2`` of the center
+ lines.
+ 'bevel'
+ the "squared-off" style. It can be thought of as a rounded corner
+ where the "circular" part of the corner has been cut off.
+
+ .. note::
+
+ Very long miter tips are cut off (to form a *bevel*) after a
+ backend-dependent limit called the "miter limit", which specifies the
+ maximum allowed ratio of miter length to line width. For example, the
+ PDF backend uses the default value of 10 specified by the PDF standard,
+ while the SVG backend does not even specify the miter limit, resulting
+ in a default value of 4 per the SVG specification. Matplotlib does not
+ currently allow the user to adjust this parameter.
+
+ A more detailed description of the effect of a miter limit can be found
+ in the `Mozilla Developer Docs
+ `_
+
+ .. plot::
+ :alt: Demo of possible JoinStyle's
+
+ from matplotlib._enums import JoinStyle
+ JoinStyle.demo()
+
+ """
+
+ miter = auto()
+ round = auto()
+ bevel = auto()
+
+ @staticmethod
+ def demo():
+ """Demonstrate how each JoinStyle looks for various join angles."""
+ import numpy as np
+ import matplotlib.pyplot as plt
+
+ def plot_angle(ax, x, y, angle, style):
+ phi = np.radians(angle)
+ xx = [x + .5, x, x + .5*np.cos(phi)]
+ yy = [y, y, y + .5*np.sin(phi)]
+ ax.plot(xx, yy, lw=12, color='tab:blue', solid_joinstyle=style)
+ ax.plot(xx, yy, lw=1, color='black')
+ ax.plot(xx[1], yy[1], 'o', color='tab:red', markersize=3)
+
+ fig, ax = plt.subplots(figsize=(5, 4), constrained_layout=True)
+ ax.set_title('Join style')
+ for x, style in enumerate(['miter', 'round', 'bevel']):
+ ax.text(x, 5, style)
+ for y, angle in enumerate([20, 45, 60, 90, 120]):
+ plot_angle(ax, x, y, angle, style)
+ if x == 0:
+ ax.text(-1.3, y, f'{angle} degrees')
+ ax.set_xlim(-1.5, 2.75)
+ ax.set_ylim(-.5, 5.5)
+ ax.set_axis_off()
+ fig.show()
+
+
+JoinStyle.input_description = "{" \
+ + ", ".join([f"'{js.name}'" for js in JoinStyle]) \
+ + "}"
+
+
+class CapStyle(str, _AutoStringNameEnum):
+ r"""
+ Define how the two endpoints (caps) of an unclosed line are drawn.
+
+ How to draw the start and end points of lines that represent a closed curve
+ (i.e. that end in a `~.path.Path.CLOSEPOLY`) is controlled by the line's
+ `JoinStyle`. For all other lines, how the start and end points are drawn is
+ controlled by the *CapStyle*.
+
+ For a visual impression of each *CapStyle*, `view these docs online
+ ` or run `CapStyle.demo`.
+
+ By default, `~.backend_bases.GraphicsContextBase` draws a stroked line as
+ squared off at its endpoints.
+
+ **Supported values:**
+
+ .. rst-class:: value-list
+
+ 'butt'
+ the line is squared off at its endpoint.
+ 'projecting'
+ the line is squared off as in *butt*, but the filled in area
+ extends beyond the endpoint a distance of ``linewidth/2``.
+ 'round'
+ like *butt*, but a semicircular cap is added to the end of the
+ line, of radius ``linewidth/2``.
+
+ .. plot::
+ :alt: Demo of possible CapStyle's
+
+ from matplotlib._enums import CapStyle
+ CapStyle.demo()
+
+ """
+ butt = auto()
+ projecting = auto()
+ round = auto()
+
+ @staticmethod
+ def demo():
+ """Demonstrate how each CapStyle looks for a thick line segment."""
+ import matplotlib.pyplot as plt
+
+ fig = plt.figure(figsize=(4, 1.2))
+ ax = fig.add_axes([0, 0, 1, 0.8])
+ ax.set_title('Cap style')
+
+ for x, style in enumerate(['butt', 'round', 'projecting']):
+ ax.text(x+0.25, 0.85, style, ha='center')
+ xx = [x, x+0.5]
+ yy = [0, 0]
+ ax.plot(xx, yy, lw=12, color='tab:blue', solid_capstyle=style)
+ ax.plot(xx, yy, lw=1, color='black')
+ ax.plot(xx, yy, 'o', color='tab:red', markersize=3)
+
+ ax.set_ylim(-.5, 1.5)
+ ax.set_axis_off()
+ fig.show()
+
+
+CapStyle.input_description = "{" \
+ + ", ".join([f"'{cs.name}'" for cs in CapStyle]) \
+ + "}"
+
+_docstring.interpd.register(
+ JoinStyle=JoinStyle.input_description,
+ CapStyle=CapStyle.input_description,
+)
diff --git a/moondream/lib/python3.10/site-packages/matplotlib/_mathtext_data.py b/moondream/lib/python3.10/site-packages/matplotlib/_mathtext_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..5819ee7430447f9ef5f6e760b65cdd5933ef9395
--- /dev/null
+++ b/moondream/lib/python3.10/site-packages/matplotlib/_mathtext_data.py
@@ -0,0 +1,1742 @@
+"""
+font data tables for truetype and afm computer modern fonts
+"""
+
+from __future__ import annotations
+from typing import overload
+
+latex_to_bakoma = {
+ '\\__sqrt__' : ('cmex10', 0x70),
+ '\\bigcap' : ('cmex10', 0x5c),
+ '\\bigcup' : ('cmex10', 0x5b),
+ '\\bigodot' : ('cmex10', 0x4b),
+ '\\bigoplus' : ('cmex10', 0x4d),
+ '\\bigotimes' : ('cmex10', 0x4f),
+ '\\biguplus' : ('cmex10', 0x5d),
+ '\\bigvee' : ('cmex10', 0x5f),
+ '\\bigwedge' : ('cmex10', 0x5e),
+ '\\coprod' : ('cmex10', 0x61),
+ '\\int' : ('cmex10', 0x5a),
+ '\\langle' : ('cmex10', 0xad),
+ '\\leftangle' : ('cmex10', 0xad),
+ '\\leftbrace' : ('cmex10', 0xa9),
+ '\\oint' : ('cmex10', 0x49),
+ '\\prod' : ('cmex10', 0x59),
+ '\\rangle' : ('cmex10', 0xae),
+ '\\rightangle' : ('cmex10', 0xae),
+ '\\rightbrace' : ('cmex10', 0xaa),
+ '\\sum' : ('cmex10', 0x58),
+ '\\widehat' : ('cmex10', 0x62),
+ '\\widetilde' : ('cmex10', 0x65),
+ '\\{' : ('cmex10', 0xa9),
+ '\\}' : ('cmex10', 0xaa),
+ '{' : ('cmex10', 0xa9),
+ '}' : ('cmex10', 0xaa),
+
+ ',' : ('cmmi10', 0x3b),
+ '.' : ('cmmi10', 0x3a),
+ '/' : ('cmmi10', 0x3d),
+ '<' : ('cmmi10', 0x3c),
+ '>' : ('cmmi10', 0x3e),
+ '\\alpha' : ('cmmi10', 0xae),
+ '\\beta' : ('cmmi10', 0xaf),
+ '\\chi' : ('cmmi10', 0xc2),
+ '\\combiningrightarrowabove' : ('cmmi10', 0x7e),
+ '\\delta' : ('cmmi10', 0xb1),
+ '\\ell' : ('cmmi10', 0x60),
+ '\\epsilon' : ('cmmi10', 0xb2),
+ '\\eta' : ('cmmi10', 0xb4),
+ '\\flat' : ('cmmi10', 0x5b),
+ '\\frown' : ('cmmi10', 0x5f),
+ '\\gamma' : ('cmmi10', 0xb0),
+ '\\imath' : ('cmmi10', 0x7b),
+ '\\iota' : ('cmmi10', 0xb6),
+ '\\jmath' : ('cmmi10', 0x7c),
+ '\\kappa' : ('cmmi10', 0x2219),
+ '\\lambda' : ('cmmi10', 0xb8),
+ '\\leftharpoondown' : ('cmmi10', 0x29),
+ '\\leftharpoonup' : ('cmmi10', 0x28),
+ '\\mu' : ('cmmi10', 0xb9),
+ '\\natural' : ('cmmi10', 0x5c),
+ '\\nu' : ('cmmi10', 0xba),
+ '\\omega' : ('cmmi10', 0x21),
+ '\\phi' : ('cmmi10', 0xc1),
+ '\\pi' : ('cmmi10', 0xbc),
+ '\\psi' : ('cmmi10', 0xc3),
+ '\\rho' : ('cmmi10', 0xbd),
+ '\\rightharpoondown' : ('cmmi10', 0x2b),
+ '\\rightharpoonup' : ('cmmi10', 0x2a),
+ '\\sharp' : ('cmmi10', 0x5d),
+ '\\sigma' : ('cmmi10', 0xbe),
+ '\\smile' : ('cmmi10', 0x5e),
+ '\\tau' : ('cmmi10', 0xbf),
+ '\\theta' : ('cmmi10', 0xb5),
+ '\\triangleleft' : ('cmmi10', 0x2f),
+ '\\triangleright' : ('cmmi10', 0x2e),
+ '\\upsilon' : ('cmmi10', 0xc0),
+ '\\varepsilon' : ('cmmi10', 0x22),
+ '\\varphi' : ('cmmi10', 0x27),
+ '\\varrho' : ('cmmi10', 0x25),
+ '\\varsigma' : ('cmmi10', 0x26),
+ '\\vartheta' : ('cmmi10', 0x23),
+ '\\wp' : ('cmmi10', 0x7d),
+ '\\xi' : ('cmmi10', 0xbb),
+ '\\zeta' : ('cmmi10', 0xb3),
+
+ '!' : ('cmr10', 0x21),
+ '%' : ('cmr10', 0x25),
+ '&' : ('cmr10', 0x26),
+ '(' : ('cmr10', 0x28),
+ ')' : ('cmr10', 0x29),
+ '+' : ('cmr10', 0x2b),
+ '0' : ('cmr10', 0x30),
+ '1' : ('cmr10', 0x31),
+ '2' : ('cmr10', 0x32),
+ '3' : ('cmr10', 0x33),
+ '4' : ('cmr10', 0x34),
+ '5' : ('cmr10', 0x35),
+ '6' : ('cmr10', 0x36),
+ '7' : ('cmr10', 0x37),
+ '8' : ('cmr10', 0x38),
+ '9' : ('cmr10', 0x39),
+ ':' : ('cmr10', 0x3a),
+ ';' : ('cmr10', 0x3b),
+ '=' : ('cmr10', 0x3d),
+ '?' : ('cmr10', 0x3f),
+ '@' : ('cmr10', 0x40),
+ '[' : ('cmr10', 0x5b),
+ '\\#' : ('cmr10', 0x23),
+ '\\$' : ('cmr10', 0x24),
+ '\\%' : ('cmr10', 0x25),
+ '\\Delta' : ('cmr10', 0xa2),
+ '\\Gamma' : ('cmr10', 0xa1),
+ '\\Lambda' : ('cmr10', 0xa4),
+ '\\Omega' : ('cmr10', 0xad),
+ '\\Phi' : ('cmr10', 0xa9),
+ '\\Pi' : ('cmr10', 0xa6),
+ '\\Psi' : ('cmr10', 0xaa),
+ '\\Sigma' : ('cmr10', 0xa7),
+ '\\Theta' : ('cmr10', 0xa3),
+ '\\Upsilon' : ('cmr10', 0xa8),
+ '\\Xi' : ('cmr10', 0xa5),
+ '\\circumflexaccent' : ('cmr10', 0x5e),
+ '\\combiningacuteaccent' : ('cmr10', 0xb6),
+ '\\combiningbreve' : ('cmr10', 0xb8),
+ '\\combiningdiaeresis' : ('cmr10', 0xc4),
+ '\\combiningdotabove' : ('cmr10', 0x5f),
+ '\\combininggraveaccent' : ('cmr10', 0xb5),
+ '\\combiningoverline' : ('cmr10', 0xb9),
+ '\\combiningtilde' : ('cmr10', 0x7e),
+ '\\leftbracket' : ('cmr10', 0x5b),
+ '\\leftparen' : ('cmr10', 0x28),
+ '\\rightbracket' : ('cmr10', 0x5d),
+ '\\rightparen' : ('cmr10', 0x29),
+ '\\widebar' : ('cmr10', 0xb9),
+ ']' : ('cmr10', 0x5d),
+
+ '*' : ('cmsy10', 0xa4),
+ '\N{MINUS SIGN}' : ('cmsy10', 0xa1),
+ '\\Downarrow' : ('cmsy10', 0x2b),
+ '\\Im' : ('cmsy10', 0x3d),
+ '\\Leftarrow' : ('cmsy10', 0x28),
+ '\\Leftrightarrow' : ('cmsy10', 0x2c),
+ '\\P' : ('cmsy10', 0x7b),
+ '\\Re' : ('cmsy10', 0x3c),
+ '\\Rightarrow' : ('cmsy10', 0x29),
+ '\\S' : ('cmsy10', 0x78),
+ '\\Uparrow' : ('cmsy10', 0x2a),
+ '\\Updownarrow' : ('cmsy10', 0x6d),
+ '\\Vert' : ('cmsy10', 0x6b),
+ '\\aleph' : ('cmsy10', 0x40),
+ '\\approx' : ('cmsy10', 0xbc),
+ '\\ast' : ('cmsy10', 0xa4),
+ '\\asymp' : ('cmsy10', 0xb3),
+ '\\backslash' : ('cmsy10', 0x6e),
+ '\\bigcirc' : ('cmsy10', 0xb0),
+ '\\bigtriangledown' : ('cmsy10', 0x35),
+ '\\bigtriangleup' : ('cmsy10', 0x34),
+ '\\bot' : ('cmsy10', 0x3f),
+ '\\bullet' : ('cmsy10', 0xb2),
+ '\\cap' : ('cmsy10', 0x5c),
+ '\\cdot' : ('cmsy10', 0xa2),
+ '\\circ' : ('cmsy10', 0xb1),
+ '\\clubsuit' : ('cmsy10', 0x7c),
+ '\\cup' : ('cmsy10', 0x5b),
+ '\\dag' : ('cmsy10', 0x79),
+ '\\dashv' : ('cmsy10', 0x61),
+ '\\ddag' : ('cmsy10', 0x7a),
+ '\\diamond' : ('cmsy10', 0xa6),
+ '\\diamondsuit' : ('cmsy10', 0x7d),
+ '\\div' : ('cmsy10', 0xa5),
+ '\\downarrow' : ('cmsy10', 0x23),
+ '\\emptyset' : ('cmsy10', 0x3b),
+ '\\equiv' : ('cmsy10', 0xb4),
+ '\\exists' : ('cmsy10', 0x39),
+ '\\forall' : ('cmsy10', 0x38),
+ '\\geq' : ('cmsy10', 0xb8),
+ '\\gg' : ('cmsy10', 0xc0),
+ '\\heartsuit' : ('cmsy10', 0x7e),
+ '\\in' : ('cmsy10', 0x32),
+ '\\infty' : ('cmsy10', 0x31),
+ '\\lbrace' : ('cmsy10', 0x66),
+ '\\lceil' : ('cmsy10', 0x64),
+ '\\leftarrow' : ('cmsy10', 0xc3),
+ '\\leftrightarrow' : ('cmsy10', 0x24),
+ '\\leq' : ('cmsy10', 0x2219),
+ '\\lfloor' : ('cmsy10', 0x62),
+ '\\ll' : ('cmsy10', 0xbf),
+ '\\mid' : ('cmsy10', 0x6a),
+ '\\mp' : ('cmsy10', 0xa8),
+ '\\nabla' : ('cmsy10', 0x72),
+ '\\nearrow' : ('cmsy10', 0x25),
+ '\\neg' : ('cmsy10', 0x3a),
+ '\\ni' : ('cmsy10', 0x33),
+ '\\nwarrow' : ('cmsy10', 0x2d),
+ '\\odot' : ('cmsy10', 0xaf),
+ '\\ominus' : ('cmsy10', 0xaa),
+ '\\oplus' : ('cmsy10', 0xa9),
+ '\\oslash' : ('cmsy10', 0xae),
+ '\\otimes' : ('cmsy10', 0xad),
+ '\\pm' : ('cmsy10', 0xa7),
+ '\\prec' : ('cmsy10', 0xc1),
+ '\\preceq' : ('cmsy10', 0xb9),
+ '\\prime' : ('cmsy10', 0x30),
+ '\\propto' : ('cmsy10', 0x2f),
+ '\\rbrace' : ('cmsy10', 0x67),
+ '\\rceil' : ('cmsy10', 0x65),
+ '\\rfloor' : ('cmsy10', 0x63),
+ '\\rightarrow' : ('cmsy10', 0x21),
+ '\\searrow' : ('cmsy10', 0x26),
+ '\\sim' : ('cmsy10', 0xbb),
+ '\\simeq' : ('cmsy10', 0x27),
+ '\\slash' : ('cmsy10', 0x36),
+ '\\spadesuit' : ('cmsy10', 0xc4),
+ '\\sqcap' : ('cmsy10', 0x75),
+ '\\sqcup' : ('cmsy10', 0x74),
+ '\\sqsubseteq' : ('cmsy10', 0x76),
+ '\\sqsupseteq' : ('cmsy10', 0x77),
+ '\\subset' : ('cmsy10', 0xbd),
+ '\\subseteq' : ('cmsy10', 0xb5),
+ '\\succ' : ('cmsy10', 0xc2),
+ '\\succeq' : ('cmsy10', 0xba),
+ '\\supset' : ('cmsy10', 0xbe),
+ '\\supseteq' : ('cmsy10', 0xb6),
+ '\\swarrow' : ('cmsy10', 0x2e),
+ '\\times' : ('cmsy10', 0xa3),
+ '\\to' : ('cmsy10', 0x21),
+ '\\top' : ('cmsy10', 0x3e),
+ '\\uparrow' : ('cmsy10', 0x22),
+ '\\updownarrow' : ('cmsy10', 0x6c),
+ '\\uplus' : ('cmsy10', 0x5d),
+ '\\vdash' : ('cmsy10', 0x60),
+ '\\vee' : ('cmsy10', 0x5f),
+ '\\vert' : ('cmsy10', 0x6a),
+ '\\wedge' : ('cmsy10', 0x5e),
+ '\\wr' : ('cmsy10', 0x6f),
+ '\\|' : ('cmsy10', 0x6b),
+ '|' : ('cmsy10', 0x6a),
+
+ '\\_' : ('cmtt10', 0x5f)
+}
+
+# Automatically generated.
+
+type12uni = {
+ 'aring' : 229,
+ 'quotedblright' : 8221,
+ 'V' : 86,
+ 'dollar' : 36,
+ 'four' : 52,
+ 'Yacute' : 221,
+ 'P' : 80,
+ 'underscore' : 95,
+ 'p' : 112,
+ 'Otilde' : 213,
+ 'perthousand' : 8240,
+ 'zero' : 48,
+ 'dotlessi' : 305,
+ 'Scaron' : 352,
+ 'zcaron' : 382,
+ 'egrave' : 232,
+ 'section' : 167,
+ 'Icircumflex' : 206,
+ 'ntilde' : 241,
+ 'ampersand' : 38,
+ 'dotaccent' : 729,
+ 'degree' : 176,
+ 'K' : 75,
+ 'acircumflex' : 226,
+ 'Aring' : 197,
+ 'k' : 107,
+ 'smalltilde' : 732,
+ 'Agrave' : 192,
+ 'divide' : 247,
+ 'ocircumflex' : 244,
+ 'asciitilde' : 126,
+ 'two' : 50,
+ 'E' : 69,
+ 'scaron' : 353,
+ 'F' : 70,
+ 'bracketleft' : 91,
+ 'asciicircum' : 94,
+ 'f' : 102,
+ 'ordmasculine' : 186,
+ 'mu' : 181,
+ 'paragraph' : 182,
+ 'nine' : 57,
+ 'v' : 118,
+ 'guilsinglleft' : 8249,
+ 'backslash' : 92,
+ 'six' : 54,
+ 'A' : 65,
+ 'icircumflex' : 238,
+ 'a' : 97,
+ 'ogonek' : 731,
+ 'q' : 113,
+ 'oacute' : 243,
+ 'ograve' : 242,
+ 'edieresis' : 235,
+ 'comma' : 44,
+ 'otilde' : 245,
+ 'guillemotright' : 187,
+ 'ecircumflex' : 234,
+ 'greater' : 62,
+ 'uacute' : 250,
+ 'L' : 76,
+ 'bullet' : 8226,
+ 'cedilla' : 184,
+ 'ydieresis' : 255,
+ 'l' : 108,
+ 'logicalnot' : 172,
+ 'exclamdown' : 161,
+ 'endash' : 8211,
+ 'agrave' : 224,
+ 'Adieresis' : 196,
+ 'germandbls' : 223,
+ 'Odieresis' : 214,
+ 'space' : 32,
+ 'quoteright' : 8217,
+ 'ucircumflex' : 251,
+ 'G' : 71,
+ 'quoteleft' : 8216,
+ 'W' : 87,
+ 'Q' : 81,
+ 'g' : 103,
+ 'w' : 119,
+ 'question' : 63,
+ 'one' : 49,
+ 'ring' : 730,
+ 'figuredash' : 8210,
+ 'B' : 66,
+ 'iacute' : 237,
+ 'Ydieresis' : 376,
+ 'R' : 82,
+ 'b' : 98,
+ 'r' : 114,
+ 'Ccedilla' : 199,
+ 'minus' : 8722,
+ 'Lslash' : 321,
+ 'Uacute' : 218,
+ 'yacute' : 253,
+ 'Ucircumflex' : 219,
+ 'quotedbl' : 34,
+ 'onehalf' : 189,
+ 'Thorn' : 222,
+ 'M' : 77,
+ 'eight' : 56,
+ 'multiply' : 215,
+ 'grave' : 96,
+ 'Ocircumflex' : 212,
+ 'm' : 109,
+ 'Ugrave' : 217,
+ 'guilsinglright' : 8250,
+ 'Ntilde' : 209,
+ 'questiondown' : 191,
+ 'Atilde' : 195,
+ 'ccedilla' : 231,
+ 'Z' : 90,
+ 'copyright' : 169,
+ 'yen' : 165,
+ 'Eacute' : 201,
+ 'H' : 72,
+ 'X' : 88,
+ 'Idieresis' : 207,
+ 'bar' : 124,
+ 'h' : 104,
+ 'x' : 120,
+ 'udieresis' : 252,
+ 'ordfeminine' : 170,
+ 'braceleft' : 123,
+ 'macron' : 175,
+ 'atilde' : 227,
+ 'Acircumflex' : 194,
+ 'Oslash' : 216,
+ 'C' : 67,
+ 'quotedblleft' : 8220,
+ 'S' : 83,
+ 'exclam' : 33,
+ 'Zcaron' : 381,
+ 'equal' : 61,
+ 's' : 115,
+ 'eth' : 240,
+ 'Egrave' : 200,
+ 'hyphen' : 45,
+ 'period' : 46,
+ 'igrave' : 236,
+ 'colon' : 58,
+ 'Ecircumflex' : 202,
+ 'trademark' : 8482,
+ 'Aacute' : 193,
+ 'cent' : 162,
+ 'lslash' : 322,
+ 'c' : 99,
+ 'N' : 78,
+ 'breve' : 728,
+ 'Oacute' : 211,
+ 'guillemotleft' : 171,
+ 'n' : 110,
+ 'idieresis' : 239,
+ 'braceright' : 125,
+ 'seven' : 55,
+ 'brokenbar' : 166,
+ 'ugrave' : 249,
+ 'periodcentered' : 183,
+ 'sterling' : 163,
+ 'I' : 73,
+ 'Y' : 89,
+ 'Eth' : 208,
+ 'emdash' : 8212,
+ 'i' : 105,
+ 'daggerdbl' : 8225,
+ 'y' : 121,
+ 'plusminus' : 177,
+ 'less' : 60,
+ 'Udieresis' : 220,
+ 'D' : 68,
+ 'five' : 53,
+ 'T' : 84,
+ 'oslash' : 248,
+ 'acute' : 180,
+ 'd' : 100,
+ 'OE' : 338,
+ 'Igrave' : 204,
+ 't' : 116,
+ 'parenright' : 41,
+ 'adieresis' : 228,
+ 'quotesingle' : 39,
+ 'twodotenleader' : 8229,
+ 'slash' : 47,
+ 'ellipsis' : 8230,
+ 'numbersign' : 35,
+ 'odieresis' : 246,
+ 'O' : 79,
+ 'oe' : 339,
+ 'o' : 111,
+ 'Edieresis' : 203,
+ 'plus' : 43,
+ 'dagger' : 8224,
+ 'three' : 51,
+ 'hungarumlaut' : 733,
+ 'parenleft' : 40,
+ 'fraction' : 8260,
+ 'registered' : 174,
+ 'J' : 74,
+ 'dieresis' : 168,
+ 'Ograve' : 210,
+ 'j' : 106,
+ 'z' : 122,
+ 'ae' : 230,
+ 'semicolon' : 59,
+ 'at' : 64,
+ 'Iacute' : 205,
+ 'percent' : 37,
+ 'bracketright' : 93,
+ 'AE' : 198,
+ 'asterisk' : 42,
+ 'aacute' : 225,
+ 'U' : 85,
+ 'eacute' : 233,
+ 'e' : 101,
+ 'thorn' : 254,
+ 'u' : 117,
+}
+
+uni2type1 = {v: k for k, v in type12uni.items()}
+
+# The script below is to sort and format the tex2uni dict
+
+## For decimal values: int(hex(v), 16)
+# newtex = {k: hex(v) for k, v in tex2uni.items()}
+# sd = dict(sorted(newtex.items(), key=lambda item: item[0]))
+#
+## For formatting the sorted dictionary with proper spacing
+## the value '24' comes from finding the longest string in
+## the newtex keys with len(max(newtex, key=len))
+# for key in sd:
+# print("{0:24} : {1: _EntryTypeOut: ...
+
+
+@overload
+def _normalize_stix_fontcodes(d: list[_EntryTypeIn]) -> list[_EntryTypeOut]: ...
+
+
+@overload
+def _normalize_stix_fontcodes(d: dict[str, list[_EntryTypeIn] |
+ dict[str, list[_EntryTypeIn]]]
+ ) -> dict[str, list[_EntryTypeOut] |
+ dict[str, list[_EntryTypeOut]]]: ...
+
+
+def _normalize_stix_fontcodes(d):
+ if isinstance(d, tuple):
+ return tuple(ord(x) if isinstance(x, str) and len(x) == 1 else x for x in d)
+ elif isinstance(d, list):
+ return [_normalize_stix_fontcodes(x) for x in d]
+ elif isinstance(d, dict):
+ return {k: _normalize_stix_fontcodes(v) for k, v in d.items()}
+
+
+stix_virtual_fonts: dict[str, dict[str, list[_EntryTypeOut]] | list[_EntryTypeOut]]
+stix_virtual_fonts = _normalize_stix_fontcodes(_stix_virtual_fonts)
+
+# Free redundant list now that it has been normalized
+del _stix_virtual_fonts
+
+# Fix some incorrect glyphs.
+stix_glyph_fixes = {
+ # Cap and Cup glyphs are swapped.
+ 0x22d2: 0x22d3,
+ 0x22d3: 0x22d2,
+}
diff --git a/moondream/lib/python3.10/site-packages/matplotlib/_path.pyi b/moondream/lib/python3.10/site-packages/matplotlib/_path.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..456905528b28e0f4eea31ec9d86433fb43767b85
--- /dev/null
+++ b/moondream/lib/python3.10/site-packages/matplotlib/_path.pyi
@@ -0,0 +1,9 @@
+from collections.abc import Sequence
+
+import numpy as np
+
+from .transforms import BboxBase
+
+def affine_transform(points: np.ndarray, trans: np.ndarray) -> np.ndarray: ...
+def count_bboxes_overlapping_bbox(bbox: BboxBase, bboxes: Sequence[BboxBase]) -> int: ...
+def update_path_extents(path, trans, rect, minpos, ignore): ...
diff --git a/moondream/lib/python3.10/site-packages/matplotlib/_qhull.pyi b/moondream/lib/python3.10/site-packages/matplotlib/_qhull.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/moondream/lib/python3.10/site-packages/matplotlib/_tight_bbox.py b/moondream/lib/python3.10/site-packages/matplotlib/_tight_bbox.py
new file mode 100644
index 0000000000000000000000000000000000000000..db72bbdff020680dfd833229cac41e9b33e428ee
--- /dev/null
+++ b/moondream/lib/python3.10/site-packages/matplotlib/_tight_bbox.py
@@ -0,0 +1,84 @@
+"""
+Helper module for the *bbox_inches* parameter in `.Figure.savefig`.
+"""
+
+from matplotlib.transforms import Bbox, TransformedBbox, Affine2D
+
+
+def adjust_bbox(fig, bbox_inches, fixed_dpi=None):
+ """
+ Temporarily adjust the figure so that only the specified area
+ (bbox_inches) is saved.
+
+ It modifies fig.bbox, fig.bbox_inches,
+ fig.transFigure._boxout, and fig.patch. While the figure size
+ changes, the scale of the original figure is conserved. A
+ function which restores the original values are returned.
+ """
+ origBbox = fig.bbox
+ origBboxInches = fig.bbox_inches
+ _boxout = fig.transFigure._boxout
+
+ old_aspect = []
+ locator_list = []
+ sentinel = object()
+ for ax in fig.axes:
+ locator = ax.get_axes_locator()
+ if locator is not None:
+ ax.apply_aspect(locator(ax, None))
+ locator_list.append(locator)
+ current_pos = ax.get_position(original=False).frozen()
+ ax.set_axes_locator(lambda a, r, _pos=current_pos: _pos)
+ # override the method that enforces the aspect ratio on the Axes
+ if 'apply_aspect' in ax.__dict__:
+ old_aspect.append(ax.apply_aspect)
+ else:
+ old_aspect.append(sentinel)
+ ax.apply_aspect = lambda pos=None: None
+
+ def restore_bbox():
+ for ax, loc, aspect in zip(fig.axes, locator_list, old_aspect):
+ ax.set_axes_locator(loc)
+ if aspect is sentinel:
+ # delete our no-op function which un-hides the original method
+ del ax.apply_aspect
+ else:
+ ax.apply_aspect = aspect
+
+ fig.bbox = origBbox
+ fig.bbox_inches = origBboxInches
+ fig.transFigure._boxout = _boxout
+ fig.transFigure.invalidate()
+ fig.patch.set_bounds(0, 0, 1, 1)
+
+ if fixed_dpi is None:
+ fixed_dpi = fig.dpi
+ tr = Affine2D().scale(fixed_dpi)
+ dpi_scale = fixed_dpi / fig.dpi
+
+ fig.bbox_inches = Bbox.from_bounds(0, 0, *bbox_inches.size)
+ x0, y0 = tr.transform(bbox_inches.p0)
+ w1, h1 = fig.bbox.size * dpi_scale
+ fig.transFigure._boxout = Bbox.from_bounds(-x0, -y0, w1, h1)
+ fig.transFigure.invalidate()
+
+ fig.bbox = TransformedBbox(fig.bbox_inches, tr)
+
+ fig.patch.set_bounds(x0 / w1, y0 / h1,
+ fig.bbox.width / w1, fig.bbox.height / h1)
+
+ return restore_bbox
+
+
+def process_figure_for_rasterizing(fig, bbox_inches_restore, fixed_dpi=None):
+ """
+ A function that needs to be called when figure dpi changes during the
+ drawing (e.g., rasterizing). It recovers the bbox and re-adjust it with
+ the new dpi.
+ """
+
+ bbox_inches, restore_bbox = bbox_inches_restore
+ restore_bbox()
+ r = adjust_bbox(fig, bbox_inches, fixed_dpi)
+
+ return bbox_inches, r
diff --git a/moondream/lib/python3.10/site-packages/matplotlib/animation.py b/moondream/lib/python3.10/site-packages/matplotlib/animation.py
new file mode 100644
index 0000000000000000000000000000000000000000..2be61284073a67f1c063b41729ac51b903b563e1
--- /dev/null
+++ b/moondream/lib/python3.10/site-packages/matplotlib/animation.py
@@ -0,0 +1,1823 @@
+import abc
+import base64
+import contextlib
+from io import BytesIO, TextIOWrapper
+import itertools
+import logging
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+from tempfile import TemporaryDirectory
+import uuid
+import warnings
+
+import numpy as np
+from PIL import Image
+
+import matplotlib as mpl
+from matplotlib._animation_data import (
+ DISPLAY_TEMPLATE, INCLUDED_FRAMES, JS_INCLUDE, STYLE_INCLUDE)
+from matplotlib import _api, cbook
+import matplotlib.colors as mcolors
+
+_log = logging.getLogger(__name__)
+
+# Process creation flag for subprocess to prevent it raising a terminal
+# window. See for example https://stackoverflow.com/q/24130623/
+subprocess_creation_flags = (
+ subprocess.CREATE_NO_WINDOW if sys.platform == 'win32' else 0)
+
+
+def adjusted_figsize(w, h, dpi, n):
+ """
+ Compute figure size so that pixels are a multiple of n.
+
+ Parameters
+ ----------
+ w, h : float
+ Size in inches.
+
+ dpi : float
+ The dpi.
+
+ n : int
+ The target multiple.
+
+ Returns
+ -------
+ wnew, hnew : float
+ The new figure size in inches.
+ """
+
+ # this maybe simplified if / when we adopt consistent rounding for
+ # pixel size across the whole library
+ def correct_roundoff(x, dpi, n):
+ if int(x*dpi) % n != 0:
+ if int(np.nextafter(x, np.inf)*dpi) % n == 0:
+ x = np.nextafter(x, np.inf)
+ elif int(np.nextafter(x, -np.inf)*dpi) % n == 0:
+ x = np.nextafter(x, -np.inf)
+ return x
+
+ wnew = int(w * dpi / n) * n / dpi
+ hnew = int(h * dpi / n) * n / dpi
+ return correct_roundoff(wnew, dpi, n), correct_roundoff(hnew, dpi, n)
+
+
+class MovieWriterRegistry:
+ """Registry of available writer classes by human readable name."""
+
+ def __init__(self):
+ self._registered = dict()
+
+ def register(self, name):
+ """
+ Decorator for registering a class under a name.
+
+ Example use::
+
+ @registry.register(name)
+ class Foo:
+ pass
+ """
+ def wrapper(writer_cls):
+ self._registered[name] = writer_cls
+ return writer_cls
+ return wrapper
+
+ def is_available(self, name):
+ """
+ Check if given writer is available by name.
+
+ Parameters
+ ----------
+ name : str
+
+ Returns
+ -------
+ bool
+ """
+ try:
+ cls = self._registered[name]
+ except KeyError:
+ return False
+ return cls.isAvailable()
+
+ def __iter__(self):
+ """Iterate over names of available writer class."""
+ for name in self._registered:
+ if self.is_available(name):
+ yield name
+
+ def list(self):
+ """Get a list of available MovieWriters."""
+ return [*self]
+
+ def __getitem__(self, name):
+ """Get an available writer class from its name."""
+ if self.is_available(name):
+ return self._registered[name]
+ raise RuntimeError(f"Requested MovieWriter ({name}) not available")
+
+
+writers = MovieWriterRegistry()
+
+
+class AbstractMovieWriter(abc.ABC):
+ """
+ Abstract base class for writing movies, providing a way to grab frames by
+ calling `~AbstractMovieWriter.grab_frame`.
+
+ `setup` is called to start the process and `finish` is called afterwards.
+ `saving` is provided as a context manager to facilitate this process as ::
+
+ with moviewriter.saving(fig, outfile='myfile.mp4', dpi=100):
+ # Iterate over frames
+ moviewriter.grab_frame(**savefig_kwargs)
+
+ The use of the context manager ensures that `setup` and `finish` are
+ performed as necessary.
+
+ An instance of a concrete subclass of this class can be given as the
+ ``writer`` argument of `Animation.save()`.
+ """
+
+ def __init__(self, fps=5, metadata=None, codec=None, bitrate=None):
+ self.fps = fps
+ self.metadata = metadata if metadata is not None else {}
+ self.codec = mpl._val_or_rc(codec, 'animation.codec')
+ self.bitrate = mpl._val_or_rc(bitrate, 'animation.bitrate')
+
+ @abc.abstractmethod
+ def setup(self, fig, outfile, dpi=None):
+ """
+ Setup for writing the movie file.
+
+ Parameters
+ ----------
+ fig : `~matplotlib.figure.Figure`
+ The figure object that contains the information for frames.
+ outfile : str
+ The filename of the resulting movie file.
+ dpi : float, default: ``fig.dpi``
+ The DPI (or resolution) for the file. This controls the size
+ in pixels of the resulting movie file.
+ """
+ # Check that path is valid
+ Path(outfile).parent.resolve(strict=True)
+ self.outfile = outfile
+ self.fig = fig
+ if dpi is None:
+ dpi = self.fig.dpi
+ self.dpi = dpi
+
+ @property
+ def frame_size(self):
+ """A tuple ``(width, height)`` in pixels of a movie frame."""
+ w, h = self.fig.get_size_inches()
+ return int(w * self.dpi), int(h * self.dpi)
+
+ def _supports_transparency(self):
+ """
+ Whether this writer supports transparency.
+
+ Writers may consult output file type and codec to determine this at runtime.
+ """
+ return False
+
+ @abc.abstractmethod
+ def grab_frame(self, **savefig_kwargs):
+ """
+ Grab the image information from the figure and save as a movie frame.
+
+ All keyword arguments in *savefig_kwargs* are passed on to the
+ `~.Figure.savefig` call that saves the figure. However, several
+ keyword arguments that are supported by `~.Figure.savefig` may not be
+ passed as they are controlled by the MovieWriter:
+
+ - *dpi*, *bbox_inches*: These may not be passed because each frame of the
+ animation much be exactly the same size in pixels.
+ - *format*: This is controlled by the MovieWriter.
+ """
+
+ @abc.abstractmethod
+ def finish(self):
+ """Finish any processing for writing the movie."""
+
+ @contextlib.contextmanager
+ def saving(self, fig, outfile, dpi, *args, **kwargs):
+ """
+ Context manager to facilitate writing the movie file.
+
+ ``*args, **kw`` are any parameters that should be passed to `setup`.
+ """
+ if mpl.rcParams['savefig.bbox'] == 'tight':
+ _log.info("Disabling savefig.bbox = 'tight', as it may cause "
+ "frame size to vary, which is inappropriate for "
+ "animation.")
+
+ # This particular sequence is what contextlib.contextmanager wants
+ self.setup(fig, outfile, dpi, *args, **kwargs)
+ with mpl.rc_context({'savefig.bbox': None}):
+ try:
+ yield self
+ finally:
+ self.finish()
+
+
+class MovieWriter(AbstractMovieWriter):
+ """
+ Base class for writing movies.
+
+ This is a base class for MovieWriter subclasses that write a movie frame
+ data to a pipe. You cannot instantiate this class directly.
+ See examples for how to use its subclasses.
+
+ Attributes
+ ----------
+ frame_format : str
+ The format used in writing frame data, defaults to 'rgba'.
+ fig : `~matplotlib.figure.Figure`
+ The figure to capture data from.
+ This must be provided by the subclasses.
+ """
+
+ # Builtin writer subclasses additionally define the _exec_key and _args_key
+ # attributes, which indicate the rcParams entries where the path to the
+ # executable and additional command-line arguments to the executable are
+ # stored. Third-party writers cannot meaningfully set these as they cannot
+ # extend rcParams with new keys.
+
+ # Pipe-based writers only support RGBA, but file-based ones support more
+ # formats.
+ supported_formats = ["rgba"]
+
+ def __init__(self, fps=5, codec=None, bitrate=None, extra_args=None,
+ metadata=None):
+ """
+ Parameters
+ ----------
+ fps : int, default: 5
+ Movie frame rate (per second).
+ codec : str or None, default: :rc:`animation.codec`
+ The codec to use.
+ bitrate : int, default: :rc:`animation.bitrate`
+ The bitrate of the movie, in kilobits per second. Higher values
+ means higher quality movies, but increase the file size. A value
+ of -1 lets the underlying movie encoder select the bitrate.
+ extra_args : list of str or None, optional
+ Extra command-line arguments passed to the underlying movie encoder. These
+ arguments are passed last to the encoder, just before the filename. The
+ default, None, means to use :rc:`animation.[name-of-encoder]_args` for the
+ builtin writers.
+ metadata : dict[str, str], default: {}
+ A dictionary of keys and values for metadata to include in the
+ output file. Some keys that may be of use include:
+ title, artist, genre, subject, copyright, srcform, comment.
+ """
+ if type(self) is MovieWriter:
+ # TODO MovieWriter is still an abstract class and needs to be
+ # extended with a mixin. This should be clearer in naming
+ # and description. For now, just give a reasonable error
+ # message to users.
+ raise TypeError(
+ 'MovieWriter cannot be instantiated directly. Please use one '
+ 'of its subclasses.')
+
+ super().__init__(fps=fps, metadata=metadata, codec=codec,
+ bitrate=bitrate)
+ self.frame_format = self.supported_formats[0]
+ self.extra_args = extra_args
+
+ def _adjust_frame_size(self):
+ if self.codec == 'h264':
+ wo, ho = self.fig.get_size_inches()
+ w, h = adjusted_figsize(wo, ho, self.dpi, 2)
+ if (wo, ho) != (w, h):
+ self.fig.set_size_inches(w, h, forward=True)
+ _log.info('figure size in inches has been adjusted '
+ 'from %s x %s to %s x %s', wo, ho, w, h)
+ else:
+ w, h = self.fig.get_size_inches()
+ _log.debug('frame size in pixels is %s x %s', *self.frame_size)
+ return w, h
+
+ def setup(self, fig, outfile, dpi=None):
+ # docstring inherited
+ super().setup(fig, outfile, dpi=dpi)
+ self._w, self._h = self._adjust_frame_size()
+ # Run here so that grab_frame() can write the data to a pipe. This
+ # eliminates the need for temp files.
+ self._run()
+
+ def _run(self):
+ # Uses subprocess to call the program for assembling frames into a
+ # movie file. *args* returns the sequence of command line arguments
+ # from a few configuration options.
+ command = self._args()
+ _log.info('MovieWriter._run: running command: %s',
+ cbook._pformat_subprocess(command))
+ PIPE = subprocess.PIPE
+ self._proc = subprocess.Popen(
+ command, stdin=PIPE, stdout=PIPE, stderr=PIPE,
+ creationflags=subprocess_creation_flags)
+
+ def finish(self):
+ """Finish any processing for writing the movie."""
+ out, err = self._proc.communicate()
+ # Use the encoding/errors that universal_newlines would use.
+ out = TextIOWrapper(BytesIO(out)).read()
+ err = TextIOWrapper(BytesIO(err)).read()
+ if out:
+ _log.log(
+ logging.WARNING if self._proc.returncode else logging.DEBUG,
+ "MovieWriter stdout:\n%s", out)
+ if err:
+ _log.log(
+ logging.WARNING if self._proc.returncode else logging.DEBUG,
+ "MovieWriter stderr:\n%s", err)
+ if self._proc.returncode:
+ raise subprocess.CalledProcessError(
+ self._proc.returncode, self._proc.args, out, err)
+
+ def grab_frame(self, **savefig_kwargs):
+ # docstring inherited
+ _validate_grabframe_kwargs(savefig_kwargs)
+ _log.debug('MovieWriter.grab_frame: Grabbing frame.')
+ # Readjust the figure size in case it has been changed by the user.
+ # All frames must have the same size to save the movie correctly.
+ self.fig.set_size_inches(self._w, self._h)
+ # Save the figure data to the sink, using the frame format and dpi.
+ self.fig.savefig(self._proc.stdin, format=self.frame_format,
+ dpi=self.dpi, **savefig_kwargs)
+
+ def _args(self):
+ """Assemble list of encoder-specific command-line arguments."""
+ return NotImplementedError("args needs to be implemented by subclass.")
+
+ @classmethod
+ def bin_path(cls):
+ """
+ Return the binary path to the commandline tool used by a specific
+ subclass. This is a class method so that the tool can be looked for
+ before making a particular MovieWriter subclass available.
+ """
+ return str(mpl.rcParams[cls._exec_key])
+
+ @classmethod
+ def isAvailable(cls):
+ """Return whether a MovieWriter subclass is actually available."""
+ return shutil.which(cls.bin_path()) is not None
+
+
+class FileMovieWriter(MovieWriter):
+ """
+ `MovieWriter` for writing to individual files and stitching at the end.
+
+ This must be sub-classed to be useful.
+ """
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.frame_format = mpl.rcParams['animation.frame_format']
+
+ def setup(self, fig, outfile, dpi=None, frame_prefix=None):
+ """
+ Setup for writing the movie file.
+
+ Parameters
+ ----------
+ fig : `~matplotlib.figure.Figure`
+ The figure to grab the rendered frames from.
+ outfile : str
+ The filename of the resulting movie file.
+ dpi : float, default: ``fig.dpi``
+ The dpi of the output file. This, with the figure size,
+ controls the size in pixels of the resulting movie file.
+ frame_prefix : str, optional
+ The filename prefix to use for temporary files. If *None* (the
+ default), files are written to a temporary directory which is
+ deleted by `finish`; if not *None*, no temporary files are
+ deleted.
+ """
+ # Check that path is valid
+ Path(outfile).parent.resolve(strict=True)
+ self.fig = fig
+ self.outfile = outfile
+ if dpi is None:
+ dpi = self.fig.dpi
+ self.dpi = dpi
+ self._adjust_frame_size()
+
+ if frame_prefix is None:
+ self._tmpdir = TemporaryDirectory()
+ self.temp_prefix = str(Path(self._tmpdir.name, 'tmp'))
+ else:
+ self._tmpdir = None
+ self.temp_prefix = frame_prefix
+ self._frame_counter = 0 # used for generating sequential file names
+ self._temp_paths = list()
+ self.fname_format_str = '%s%%07d.%s'
+
+ def __del__(self):
+ if hasattr(self, '_tmpdir') and self._tmpdir:
+ self._tmpdir.cleanup()
+
+ @property
+ def frame_format(self):
+ """
+ Format (png, jpeg, etc.) to use for saving the frames, which can be
+ decided by the individual subclasses.
+ """
+ return self._frame_format
+
+ @frame_format.setter
+ def frame_format(self, frame_format):
+ if frame_format in self.supported_formats:
+ self._frame_format = frame_format
+ else:
+ _api.warn_external(
+ f"Ignoring file format {frame_format!r} which is not "
+ f"supported by {type(self).__name__}; using "
+ f"{self.supported_formats[0]} instead.")
+ self._frame_format = self.supported_formats[0]
+
+ def _base_temp_name(self):
+ # Generates a template name (without number) given the frame format
+ # for extension and the prefix.
+ return self.fname_format_str % (self.temp_prefix, self.frame_format)
+
+ def grab_frame(self, **savefig_kwargs):
+ # docstring inherited
+ # Creates a filename for saving using basename and counter.
+ _validate_grabframe_kwargs(savefig_kwargs)
+ path = Path(self._base_temp_name() % self._frame_counter)
+ self._temp_paths.append(path) # Record the filename for later use.
+ self._frame_counter += 1 # Ensures each created name is unique.
+ _log.debug('FileMovieWriter.grab_frame: Grabbing frame %d to path=%s',
+ self._frame_counter, path)
+ with open(path, 'wb') as sink: # Save figure to the sink.
+ self.fig.savefig(sink, format=self.frame_format, dpi=self.dpi,
+ **savefig_kwargs)
+
+ def finish(self):
+ # Call run here now that all frame grabbing is done. All temp files
+ # are available to be assembled.
+ try:
+ self._run()
+ super().finish()
+ finally:
+ if self._tmpdir:
+ _log.debug(
+ 'MovieWriter: clearing temporary path=%s', self._tmpdir
+ )
+ self._tmpdir.cleanup()
+
+
+@writers.register('pillow')
+class PillowWriter(AbstractMovieWriter):
+ def _supports_transparency(self):
+ return True
+
+ @classmethod
+ def isAvailable(cls):
+ return True
+
+ def setup(self, fig, outfile, dpi=None):
+ super().setup(fig, outfile, dpi=dpi)
+ self._frames = []
+
+ def grab_frame(self, **savefig_kwargs):
+ _validate_grabframe_kwargs(savefig_kwargs)
+ buf = BytesIO()
+ self.fig.savefig(
+ buf, **{**savefig_kwargs, "format": "rgba", "dpi": self.dpi})
+ im = Image.frombuffer(
+ "RGBA", self.frame_size, buf.getbuffer(), "raw", "RGBA", 0, 1)
+ if im.getextrema()[3][0] < 255:
+ # This frame has transparency, so we'll just add it as is.
+ self._frame.append(im)
+ else:
+ # Without transparency, we switch to RGB mode, which converts to P mode a
+ # little better if needed (specifically, this helps with GIF output.)
+ self._frames.append(im.convert("RGB"))
+
+ def finish(self):
+ self._frames[0].save(
+ self.outfile, save_all=True, append_images=self._frames[1:],
+ duration=int(1000 / self.fps), loop=0)
+
+
+# Base class of ffmpeg information. Has the config keys and the common set
+# of arguments that controls the *output* side of things.
+class FFMpegBase:
+ """
+ Mixin class for FFMpeg output.
+
+ This is a base class for the concrete `FFMpegWriter` and `FFMpegFileWriter`
+ classes.
+ """
+
+ _exec_key = 'animation.ffmpeg_path'
+ _args_key = 'animation.ffmpeg_args'
+
+ def _supports_transparency(self):
+ suffix = Path(self.outfile).suffix
+ if suffix in {'.apng', '.avif', '.gif', '.webm', '.webp'}:
+ return True
+ # This list was found by going through `ffmpeg -codecs` for video encoders,
+ # running them with _support_transparency() forced to True, and checking that
+ # the "Pixel format" in Kdenlive included alpha. Note this is not a guarantee
+ # that transparency will work; you may also need to pass `-pix_fmt`, but we
+ # trust the user has done so if they are asking for these formats.
+ return self.codec in {
+ 'apng', 'avrp', 'bmp', 'cfhd', 'dpx', 'ffv1', 'ffvhuff', 'gif', 'huffyuv',
+ 'jpeg2000', 'ljpeg', 'png', 'prores', 'prores_aw', 'prores_ks', 'qtrle',
+ 'rawvideo', 'targa', 'tiff', 'utvideo', 'v408', }
+
+ @property
+ def output_args(self):
+ args = []
+ suffix = Path(self.outfile).suffix
+ if suffix in {'.apng', '.avif', '.gif', '.webm', '.webp'}:
+ self.codec = suffix[1:]
+ else:
+ args.extend(['-vcodec', self.codec])
+ extra_args = (self.extra_args if self.extra_args is not None
+ else mpl.rcParams[self._args_key])
+ # For h264, the default format is yuv444p, which is not compatible
+ # with quicktime (and others). Specifying yuv420p fixes playback on
+ # iOS, as well as HTML5 video in firefox and safari (on both Windows and
+ # macOS). Also fixes internet explorer. This is as of 2015/10/29.
+ if self.codec == 'h264' and '-pix_fmt' not in extra_args:
+ args.extend(['-pix_fmt', 'yuv420p'])
+ # For GIF, we're telling FFmpeg to split the video stream, to generate
+ # a palette, and then use it for encoding.
+ elif self.codec == 'gif' and '-filter_complex' not in extra_args:
+ args.extend(['-filter_complex',
+ 'split [a][b];[a] palettegen [p];[b][p] paletteuse'])
+ # For AVIF, we're telling FFmpeg to split the video stream, extract the alpha,
+ # in order to place it in a secondary stream, as needed by AVIF-in-FFmpeg.
+ elif self.codec == 'avif' and '-filter_complex' not in extra_args:
+ args.extend(['-filter_complex',
+ 'split [rgb][rgba]; [rgba] alphaextract [alpha]',
+ '-map', '[rgb]', '-map', '[alpha]'])
+ if self.bitrate > 0:
+ args.extend(['-b', '%dk' % self.bitrate]) # %dk: bitrate in kbps.
+ for k, v in self.metadata.items():
+ args.extend(['-metadata', f'{k}={v}'])
+ args.extend(extra_args)
+
+ return args + ['-y', self.outfile]
+
+
+# Combine FFMpeg options with pipe-based writing
+@writers.register('ffmpeg')
+class FFMpegWriter(FFMpegBase, MovieWriter):
+ """
+ Pipe-based ffmpeg writer.
+
+ Frames are streamed directly to ffmpeg via a pipe and written in a single pass.
+
+ This effectively works as a slideshow input to ffmpeg with the fps passed as
+ ``-framerate``, so see also `their notes on frame rates`_ for further details.
+
+ .. _their notes on frame rates: https://trac.ffmpeg.org/wiki/Slideshow#Framerates
+ """
+ def _args(self):
+ # Returns the command line parameters for subprocess to use
+ # ffmpeg to create a movie using a pipe.
+ args = [self.bin_path(), '-f', 'rawvideo', '-vcodec', 'rawvideo',
+ '-s', '%dx%d' % self.frame_size, '-pix_fmt', self.frame_format,
+ '-framerate', str(self.fps)]
+ # Logging is quieted because subprocess.PIPE has limited buffer size.
+ # If you have a lot of frames in your animation and set logging to
+ # DEBUG, you will have a buffer overrun.
+ if _log.getEffectiveLevel() > logging.DEBUG:
+ args += ['-loglevel', 'error']
+ args += ['-i', 'pipe:'] + self.output_args
+ return args
+
+
+# Combine FFMpeg options with temp file-based writing
+@writers.register('ffmpeg_file')
+class FFMpegFileWriter(FFMpegBase, FileMovieWriter):
+ """
+ File-based ffmpeg writer.
+
+ Frames are written to temporary files on disk and then stitched together at the end.
+
+ This effectively works as a slideshow input to ffmpeg with the fps passed as
+ ``-framerate``, so see also `their notes on frame rates`_ for further details.
+
+ .. _their notes on frame rates: https://trac.ffmpeg.org/wiki/Slideshow#Framerates
+ """
+ supported_formats = ['png', 'jpeg', 'tiff', 'raw', 'rgba']
+
+ def _args(self):
+ # Returns the command line parameters for subprocess to use
+ # ffmpeg to create a movie using a collection of temp images
+ args = []
+ # For raw frames, we need to explicitly tell ffmpeg the metadata.
+ if self.frame_format in {'raw', 'rgba'}:
+ args += [
+ '-f', 'image2', '-vcodec', 'rawvideo',
+ '-video_size', '%dx%d' % self.frame_size,
+ '-pixel_format', 'rgba',
+ ]
+ args += ['-framerate', str(self.fps), '-i', self._base_temp_name()]
+ if not self._tmpdir:
+ args += ['-frames:v', str(self._frame_counter)]
+ # Logging is quieted because subprocess.PIPE has limited buffer size.
+ # If you have a lot of frames in your animation and set logging to
+ # DEBUG, you will have a buffer overrun.
+ if _log.getEffectiveLevel() > logging.DEBUG:
+ args += ['-loglevel', 'error']
+ return [self.bin_path(), *args, *self.output_args]
+
+
+# Base class for animated GIFs with ImageMagick
+class ImageMagickBase:
+ """
+ Mixin class for ImageMagick output.
+
+ This is a base class for the concrete `ImageMagickWriter` and
+ `ImageMagickFileWriter` classes, which define an ``input_names`` attribute
+ (or property) specifying the input names passed to ImageMagick.
+ """
+
+ _exec_key = 'animation.convert_path'
+ _args_key = 'animation.convert_args'
+
+ def _supports_transparency(self):
+ suffix = Path(self.outfile).suffix
+ return suffix in {'.apng', '.avif', '.gif', '.webm', '.webp'}
+
+ def _args(self):
+ # ImageMagick does not recognize "raw".
+ fmt = "rgba" if self.frame_format == "raw" else self.frame_format
+ extra_args = (self.extra_args if self.extra_args is not None
+ else mpl.rcParams[self._args_key])
+ return [
+ self.bin_path(),
+ "-size", "%ix%i" % self.frame_size,
+ "-depth", "8",
+ "-delay", str(100 / self.fps),
+ "-loop", "0",
+ f"{fmt}:{self.input_names}",
+ *extra_args,
+ self.outfile,
+ ]
+
+ @classmethod
+ def bin_path(cls):
+ binpath = super().bin_path()
+ if binpath == 'convert':
+ binpath = mpl._get_executable_info('magick').executable
+ return binpath
+
+ @classmethod
+ def isAvailable(cls):
+ try:
+ return super().isAvailable()
+ except mpl.ExecutableNotFoundError as _enf:
+ # May be raised by get_executable_info.
+ _log.debug('ImageMagick unavailable due to: %s', _enf)
+ return False
+
+
+# Combine ImageMagick options with pipe-based writing
+@writers.register('imagemagick')
+class ImageMagickWriter(ImageMagickBase, MovieWriter):
+ """
+ Pipe-based animated gif writer.
+
+ Frames are streamed directly to ImageMagick via a pipe and written
+ in a single pass.
+ """
+
+ input_names = "-" # stdin
+
+
+# Combine ImageMagick options with temp file-based writing
+@writers.register('imagemagick_file')
+class ImageMagickFileWriter(ImageMagickBase, FileMovieWriter):
+ """
+ File-based animated gif writer.
+
+ Frames are written to temporary files on disk and then stitched
+ together at the end.
+ """
+
+ supported_formats = ['png', 'jpeg', 'tiff', 'raw', 'rgba']
+ input_names = property(
+ lambda self: f'{self.temp_prefix}*.{self.frame_format}')
+
+
+# Taken directly from jakevdp's JSAnimation package at
+# http://github.com/jakevdp/JSAnimation
+def _included_frames(frame_count, frame_format, frame_dir):
+ return INCLUDED_FRAMES.format(Nframes=frame_count,
+ frame_dir=frame_dir,
+ frame_format=frame_format)
+
+
+def _embedded_frames(frame_list, frame_format):
+ """frame_list should be a list of base64-encoded png files"""
+ if frame_format == 'svg':
+ # Fix MIME type for svg
+ frame_format = 'svg+xml'
+ template = ' frames[{0}] = "data:image/{1};base64,{2}"\n'
+ return "\n" + "".join(
+ template.format(i, frame_format, frame_data.replace('\n', '\\\n'))
+ for i, frame_data in enumerate(frame_list))
+
+
+@writers.register('html')
+class HTMLWriter(FileMovieWriter):
+ """Writer for JavaScript-based HTML movies."""
+
+ supported_formats = ['png', 'jpeg', 'tiff', 'svg']
+
+ @classmethod
+ def isAvailable(cls):
+ return True
+
+ def __init__(self, fps=30, codec=None, bitrate=None, extra_args=None,
+ metadata=None, embed_frames=False, default_mode='loop',
+ embed_limit=None):
+
+ if extra_args:
+ _log.warning("HTMLWriter ignores 'extra_args'")
+ extra_args = () # Don't lookup nonexistent rcParam[args_key].
+ self.embed_frames = embed_frames
+ self.default_mode = default_mode.lower()
+ _api.check_in_list(['loop', 'once', 'reflect'],
+ default_mode=self.default_mode)
+
+ # Save embed limit, which is given in MB
+ self._bytes_limit = mpl._val_or_rc(embed_limit, 'animation.embed_limit')
+ # Convert from MB to bytes
+ self._bytes_limit *= 1024 * 1024
+
+ super().__init__(fps, codec, bitrate, extra_args, metadata)
+
+ def setup(self, fig, outfile, dpi=None, frame_dir=None):
+ outfile = Path(outfile)
+ _api.check_in_list(['.html', '.htm'], outfile_extension=outfile.suffix)
+
+ self._saved_frames = []
+ self._total_bytes = 0
+ self._hit_limit = False
+
+ if not self.embed_frames:
+ if frame_dir is None:
+ frame_dir = outfile.with_name(outfile.stem + '_frames')
+ frame_dir.mkdir(parents=True, exist_ok=True)
+ frame_prefix = frame_dir / 'frame'
+ else:
+ frame_prefix = None
+
+ super().setup(fig, outfile, dpi, frame_prefix)
+ self._clear_temp = False
+
+ def grab_frame(self, **savefig_kwargs):
+ _validate_grabframe_kwargs(savefig_kwargs)
+ if self.embed_frames:
+ # Just stop processing if we hit the limit
+ if self._hit_limit:
+ return
+ f = BytesIO()
+ self.fig.savefig(f, format=self.frame_format,
+ dpi=self.dpi, **savefig_kwargs)
+ imgdata64 = base64.encodebytes(f.getvalue()).decode('ascii')
+ self._total_bytes += len(imgdata64)
+ if self._total_bytes >= self._bytes_limit:
+ _log.warning(
+ "Animation size has reached %s bytes, exceeding the limit "
+ "of %s. If you're sure you want a larger animation "
+ "embedded, set the animation.embed_limit rc parameter to "
+ "a larger value (in MB). This and further frames will be "
+ "dropped.", self._total_bytes, self._bytes_limit)
+ self._hit_limit = True
+ else:
+ self._saved_frames.append(imgdata64)
+ else:
+ return super().grab_frame(**savefig_kwargs)
+
+ def finish(self):
+ # save the frames to an html file
+ if self.embed_frames:
+ fill_frames = _embedded_frames(self._saved_frames,
+ self.frame_format)
+ frame_count = len(self._saved_frames)
+ else:
+ # temp names is filled by FileMovieWriter
+ frame_count = len(self._temp_paths)
+ fill_frames = _included_frames(
+ frame_count, self.frame_format,
+ self._temp_paths[0].parent.relative_to(self.outfile.parent))
+ mode_dict = dict(once_checked='',
+ loop_checked='',
+ reflect_checked='')
+ mode_dict[self.default_mode + '_checked'] = 'checked'
+
+ interval = 1000 // self.fps
+
+ with open(self.outfile, 'w') as of:
+ of.write(JS_INCLUDE + STYLE_INCLUDE)
+ of.write(DISPLAY_TEMPLATE.format(id=uuid.uuid4().hex,
+ Nframes=frame_count,
+ fill_frames=fill_frames,
+ interval=interval,
+ **mode_dict))
+
+ # Duplicate the temporary file clean up logic from
+ # FileMovieWriter.finish. We cannot call the inherited version of
+ # finish because it assumes that there is a subprocess that we either
+ # need to call to merge many frames together or that there is a
+ # subprocess call that we need to clean up.
+ if self._tmpdir:
+ _log.debug('MovieWriter: clearing temporary path=%s', self._tmpdir)
+ self._tmpdir.cleanup()
+
+
+class Animation:
+ """
+ A base class for Animations.
+
+ This class is not usable as is, and should be subclassed to provide needed
+ behavior.
+
+ .. note::
+
+ You must store the created Animation in a variable that lives as long
+ as the animation should run. Otherwise, the Animation object will be
+ garbage-collected and the animation stops.
+
+ Parameters
+ ----------
+ fig : `~matplotlib.figure.Figure`
+ The figure object used to get needed events, such as draw or resize.
+
+ event_source : object, optional
+ A class that can run a callback when desired events
+ are generated, as well as be stopped and started.
+
+ Examples include timers (see `TimedAnimation`) and file
+ system notifications.
+
+ blit : bool, default: False
+ Whether blitting is used to optimize drawing. If the backend does not
+ support blitting, then this parameter has no effect.
+
+ See Also
+ --------
+ FuncAnimation, ArtistAnimation
+ """
+
+ def __init__(self, fig, event_source=None, blit=False):
+ self._draw_was_started = False
+
+ self._fig = fig
+ # Disables blitting for backends that don't support it. This
+ # allows users to request it if available, but still have a
+ # fallback that works if it is not.
+ self._blit = blit and fig.canvas.supports_blit
+
+ # These are the basics of the animation. The frame sequence represents
+ # information for each frame of the animation and depends on how the
+ # drawing is handled by the subclasses. The event source fires events
+ # that cause the frame sequence to be iterated.
+ self.frame_seq = self.new_frame_seq()
+ self.event_source = event_source
+
+ # Instead of starting the event source now, we connect to the figure's
+ # draw_event, so that we only start once the figure has been drawn.
+ self._first_draw_id = fig.canvas.mpl_connect('draw_event', self._start)
+
+ # Connect to the figure's close_event so that we don't continue to
+ # fire events and try to draw to a deleted figure.
+ self._close_id = self._fig.canvas.mpl_connect('close_event',
+ self._stop)
+ if self._blit:
+ self._setup_blit()
+
+ def __del__(self):
+ if not getattr(self, '_draw_was_started', True):
+ warnings.warn(
+ 'Animation was deleted without rendering anything. This is '
+ 'most likely not intended. To prevent deletion, assign the '
+ 'Animation to a variable, e.g. `anim`, that exists until you '
+ 'output the Animation using `plt.show()` or '
+ '`anim.save()`.'
+ )
+
+ def _start(self, *args):
+ """
+ Starts interactive animation. Adds the draw frame command to the GUI
+ handler, calls show to start the event loop.
+ """
+ # Do not start the event source if saving() it.
+ if self._fig.canvas.is_saving():
+ return
+ # First disconnect our draw event handler
+ self._fig.canvas.mpl_disconnect(self._first_draw_id)
+
+ # Now do any initial draw
+ self._init_draw()
+
+ # Add our callback for stepping the animation and
+ # actually start the event_source.
+ self.event_source.add_callback(self._step)
+ self.event_source.start()
+
+ def _stop(self, *args):
+ # On stop we disconnect all of our events.
+ if self._blit:
+ self._fig.canvas.mpl_disconnect(self._resize_id)
+ self._fig.canvas.mpl_disconnect(self._close_id)
+ self.event_source.remove_callback(self._step)
+ self.event_source = None
+
+ def save(self, filename, writer=None, fps=None, dpi=None, codec=None,
+ bitrate=None, extra_args=None, metadata=None, extra_anim=None,
+ savefig_kwargs=None, *, progress_callback=None):
+ """
+ Save the animation as a movie file by drawing every frame.
+
+ Parameters
+ ----------
+ filename : str
+ The output filename, e.g., :file:`mymovie.mp4`.
+
+ writer : `MovieWriter` or str, default: :rc:`animation.writer`
+ A `MovieWriter` instance to use or a key that identifies a
+ class to use, such as 'ffmpeg'.
+
+ fps : int, optional
+ Movie frame rate (per second). If not set, the frame rate from the
+ animation's frame interval.
+
+ dpi : float, default: :rc:`savefig.dpi`
+ Controls the dots per inch for the movie frames. Together with
+ the figure's size in inches, this controls the size of the movie.
+
+ codec : str, default: :rc:`animation.codec`.
+ The video codec to use. Not all codecs are supported by a given
+ `MovieWriter`.
+
+ bitrate : int, default: :rc:`animation.bitrate`
+ The bitrate of the movie, in kilobits per second. Higher values
+ means higher quality movies, but increase the file size. A value
+ of -1 lets the underlying movie encoder select the bitrate.
+
+ extra_args : list of str or None, optional
+ Extra command-line arguments passed to the underlying movie encoder. These
+ arguments are passed last to the encoder, just before the output filename.
+ The default, None, means to use :rc:`animation.[name-of-encoder]_args` for
+ the builtin writers.
+
+ metadata : dict[str, str], default: {}
+ Dictionary of keys and values for metadata to include in
+ the output file. Some keys that may be of use include:
+ title, artist, genre, subject, copyright, srcform, comment.
+
+ extra_anim : list, default: []
+ Additional `Animation` objects that should be included
+ in the saved movie file. These need to be from the same
+ `.Figure` instance. Also, animation frames will
+ just be simply combined, so there should be a 1:1 correspondence
+ between the frames from the different animations.
+
+ savefig_kwargs : dict, default: {}
+ Keyword arguments passed to each `~.Figure.savefig` call used to
+ save the individual frames.
+
+ progress_callback : function, optional
+ A callback function that will be called for every frame to notify
+ the saving progress. It must have the signature ::
+
+ def func(current_frame: int, total_frames: int) -> Any
+
+ where *current_frame* is the current frame number and *total_frames* is the
+ total number of frames to be saved. *total_frames* is set to None, if the
+ total number of frames cannot be determined. Return values may exist but are
+ ignored.
+
+ Example code to write the progress to stdout::
+
+ progress_callback = lambda i, n: print(f'Saving frame {i}/{n}')
+
+ Notes
+ -----
+ *fps*, *codec*, *bitrate*, *extra_args* and *metadata* are used to
+ construct a `.MovieWriter` instance and can only be passed if
+ *writer* is a string. If they are passed as non-*None* and *writer*
+ is a `.MovieWriter`, a `RuntimeError` will be raised.
+ """
+
+ all_anim = [self]
+ if extra_anim is not None:
+ all_anim.extend(anim for anim in extra_anim
+ if anim._fig is self._fig)
+
+ # Disable "Animation was deleted without rendering" warning.
+ for anim in all_anim:
+ anim._draw_was_started = True
+
+ if writer is None:
+ writer = mpl.rcParams['animation.writer']
+ elif (not isinstance(writer, str) and
+ any(arg is not None
+ for arg in (fps, codec, bitrate, extra_args, metadata))):
+ raise RuntimeError('Passing in values for arguments '
+ 'fps, codec, bitrate, extra_args, or metadata '
+ 'is not supported when writer is an existing '
+ 'MovieWriter instance. These should instead be '
+ 'passed as arguments when creating the '
+ 'MovieWriter instance.')
+
+ if savefig_kwargs is None:
+ savefig_kwargs = {}
+ else:
+ # we are going to mutate this below
+ savefig_kwargs = dict(savefig_kwargs)
+
+ if fps is None and hasattr(self, '_interval'):
+ # Convert interval in ms to frames per second
+ fps = 1000. / self._interval
+
+ # Reuse the savefig DPI for ours if none is given.
+ dpi = mpl._val_or_rc(dpi, 'savefig.dpi')
+ if dpi == 'figure':
+ dpi = self._fig.dpi
+
+ writer_kwargs = {}
+ if codec is not None:
+ writer_kwargs['codec'] = codec
+ if bitrate is not None:
+ writer_kwargs['bitrate'] = bitrate
+ if extra_args is not None:
+ writer_kwargs['extra_args'] = extra_args
+ if metadata is not None:
+ writer_kwargs['metadata'] = metadata
+
+ # If we have the name of a writer, instantiate an instance of the
+ # registered class.
+ if isinstance(writer, str):
+ try:
+ writer_cls = writers[writer]
+ except RuntimeError: # Raised if not available.
+ writer_cls = PillowWriter # Always available.
+ _log.warning("MovieWriter %s unavailable; using Pillow "
+ "instead.", writer)
+ writer = writer_cls(fps, **writer_kwargs)
+ _log.info('Animation.save using %s', type(writer))
+
+ if 'bbox_inches' in savefig_kwargs:
+ _log.warning("Warning: discarding the 'bbox_inches' argument in "
+ "'savefig_kwargs' as it may cause frame size "
+ "to vary, which is inappropriate for animation.")
+ savefig_kwargs.pop('bbox_inches')
+
+ # Create a new sequence of frames for saved data. This is different
+ # from new_frame_seq() to give the ability to save 'live' generated
+ # frame information to be saved later.
+ # TODO: Right now, after closing the figure, saving a movie won't work
+ # since GUI widgets are gone. Either need to remove extra code to
+ # allow for this non-existent use case or find a way to make it work.
+
+ def _pre_composite_to_white(color):
+ r, g, b, a = mcolors.to_rgba(color)
+ return a * np.array([r, g, b]) + 1 - a
+
+ # canvas._is_saving = True makes the draw_event animation-starting
+ # callback a no-op; canvas.manager = None prevents resizing the GUI
+ # widget (both are likewise done in savefig()).
+ with (writer.saving(self._fig, filename, dpi),
+ cbook._setattr_cm(self._fig.canvas, _is_saving=True, manager=None)):
+ if not writer._supports_transparency():
+ facecolor = savefig_kwargs.get('facecolor',
+ mpl.rcParams['savefig.facecolor'])
+ if facecolor == 'auto':
+ facecolor = self._fig.get_facecolor()
+ savefig_kwargs['facecolor'] = _pre_composite_to_white(facecolor)
+ savefig_kwargs['transparent'] = False # just to be safe!
+
+ for anim in all_anim:
+ anim._init_draw() # Clear the initial frame
+ frame_number = 0
+ # TODO: Currently only FuncAnimation has a save_count
+ # attribute. Can we generalize this to all Animations?
+ save_count_list = [getattr(a, '_save_count', None)
+ for a in all_anim]
+ if None in save_count_list:
+ total_frames = None
+ else:
+ total_frames = sum(save_count_list)
+ for data in zip(*[a.new_saved_frame_seq() for a in all_anim]):
+ for anim, d in zip(all_anim, data):
+ # TODO: See if turning off blit is really necessary
+ anim._draw_next_frame(d, blit=False)
+ if progress_callback is not None:
+ progress_callback(frame_number, total_frames)
+ frame_number += 1
+ writer.grab_frame(**savefig_kwargs)
+
+ def _step(self, *args):
+ """
+ Handler for getting events. By default, gets the next frame in the
+ sequence and hands the data off to be drawn.
+ """
+ # Returns True to indicate that the event source should continue to
+ # call _step, until the frame sequence reaches the end of iteration,
+ # at which point False will be returned.
+ try:
+ framedata = next(self.frame_seq)
+ self._draw_next_frame(framedata, self._blit)
+ return True
+ except StopIteration:
+ return False
+
+ def new_frame_seq(self):
+ """Return a new sequence of frame information."""
+ # Default implementation is just an iterator over self._framedata
+ return iter(self._framedata)
+
+ def new_saved_frame_seq(self):
+ """Return a new sequence of saved/cached frame information."""
+ # Default is the same as the regular frame sequence
+ return self.new_frame_seq()
+
+ def _draw_next_frame(self, framedata, blit):
+ # Breaks down the drawing of the next frame into steps of pre- and
+ # post- draw, as well as the drawing of the frame itself.
+ self._pre_draw(framedata, blit)
+ self._draw_frame(framedata)
+ self._post_draw(framedata, blit)
+
+ def _init_draw(self):
+ # Initial draw to clear the frame. Also used by the blitting code
+ # when a clean base is required.
+ self._draw_was_started = True
+
+ def _pre_draw(self, framedata, blit):
+ # Perform any cleaning or whatnot before the drawing of the frame.
+ # This default implementation allows blit to clear the frame.
+ if blit:
+ self._blit_clear(self._drawn_artists)
+
+ def _draw_frame(self, framedata):
+ # Performs actual drawing of the frame.
+ raise NotImplementedError('Needs to be implemented by subclasses to'
+ ' actually make an animation.')
+
+ def _post_draw(self, framedata, blit):
+ # After the frame is rendered, this handles the actual flushing of
+ # the draw, which can be a direct draw_idle() or make use of the
+ # blitting.
+ if blit and self._drawn_artists:
+ self._blit_draw(self._drawn_artists)
+ else:
+ self._fig.canvas.draw_idle()
+
+ # The rest of the code in this class is to facilitate easy blitting
+ def _blit_draw(self, artists):
+ # Handles blitted drawing, which renders only the artists given instead
+ # of the entire figure.
+ updated_ax = {a.axes for a in artists}
+ # Enumerate artists to cache Axes backgrounds. We do not draw
+ # artists yet to not cache foreground from plots with shared Axes
+ for ax in updated_ax:
+ # If we haven't cached the background for the current view of this
+ # Axes object, do so now. This might not always be reliable, but
+ # it's an attempt to automate the process.
+ cur_view = ax._get_view()
+ view, bg = self._blit_cache.get(ax, (object(), None))
+ if cur_view != view:
+ self._blit_cache[ax] = (
+ cur_view, ax.figure.canvas.copy_from_bbox(ax.bbox))
+ # Make a separate pass to draw foreground.
+ for a in artists:
+ a.axes.draw_artist(a)
+ # After rendering all the needed artists, blit each Axes individually.
+ for ax in updated_ax:
+ ax.figure.canvas.blit(ax.bbox)
+
+ def _blit_clear(self, artists):
+ # Get a list of the Axes that need clearing from the artists that
+ # have been drawn. Grab the appropriate saved background from the
+ # cache and restore.
+ axes = {a.axes for a in artists}
+ for ax in axes:
+ try:
+ view, bg = self._blit_cache[ax]
+ except KeyError:
+ continue
+ if ax._get_view() == view:
+ ax.figure.canvas.restore_region(bg)
+ else:
+ self._blit_cache.pop(ax)
+
+ def _setup_blit(self):
+ # Setting up the blit requires: a cache of the background for the Axes
+ self._blit_cache = dict()
+ self._drawn_artists = []
+ # _post_draw needs to be called first to initialize the renderer
+ self._post_draw(None, self._blit)
+ # Then we need to clear the Frame for the initial draw
+ # This is typically handled in _on_resize because QT and Tk
+ # emit a resize event on launch, but the macosx backend does not,
+ # thus we force it here for everyone for consistency
+ self._init_draw()
+ # Connect to future resize events
+ self._resize_id = self._fig.canvas.mpl_connect('resize_event',
+ self._on_resize)
+
+ def _on_resize(self, event):
+ # On resize, we need to disable the resize event handling so we don't
+ # get too many events. Also stop the animation events, so that
+ # we're paused. Reset the cache and re-init. Set up an event handler
+ # to catch once the draw has actually taken place.
+ self._fig.canvas.mpl_disconnect(self._resize_id)
+ self.event_source.stop()
+ self._blit_cache.clear()
+ self._init_draw()
+ self._resize_id = self._fig.canvas.mpl_connect('draw_event',
+ self._end_redraw)
+
+ def _end_redraw(self, event):
+ # Now that the redraw has happened, do the post draw flushing and
+ # blit handling. Then re-enable all of the original events.
+ self._post_draw(None, False)
+ self.event_source.start()
+ self._fig.canvas.mpl_disconnect(self._resize_id)
+ self._resize_id = self._fig.canvas.mpl_connect('resize_event',
+ self._on_resize)
+
+ def to_html5_video(self, embed_limit=None):
+ """
+ Convert the animation to an HTML5 ``