"""

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 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()):

import setuptools_scm

return setuptools_scm.get_version(

root=root,

version_scheme="release-branch-semver",

local_scheme="node-and-date",

fallback_version=_version.version,

)

else: # Get the version from the _version.py setuptools_scm file.

# Quickfix to ensure Microsoft Visual C++ redistributable

# DLLs are loaded before importing kiwisolver

from . import ft2font

for modname, minver in [

("cycler", "0.10"),

("dateutil", "2.7"),

("kiwisolver", "1.0.1"),

("numpy", "1.21"),

("pyparsing", "2.3.1"),

]:

module = importlib.import_module(modname)

if parse_version(module.__version__) < parse_version(minver):

raise ImportError(f"Matplotlib requires {modname}>={minver}; "

"""

handler = logging.StreamHandler()

handler.setFormatter(logging.Formatter(logging.BASIC_FORMAT))

_log.addHandler(handler)

"""

_log.setLevel(level.upper())

"""

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

"""

"""

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:

"""

"""

configdir = os.environ.get('MPLCONFIGDIR')

if configdir:

configdir = Path(configdir).resolve()

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"

try:

configdir.mkdir(parents=True, exist_ok=True)

except OSError:

pass

else:

if os.access(str(configdir), os.W_OK) and configdir.is_dir():

return str(configdir)

# If the config or cache directory cannot be created or is not a writable

# directory, create a temporary one.

tmpdir = os.environ["MPLCONFIGDIR"] = \

tempfile.mkdtemp(prefix="matplotlib-")

atexit.register(shutil.rmtree, tmpdir)

_log.warning(

"Matplotlib created a temporary config/cache directory at %s because "

"the default path (%s) is not a writable directory; 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)

"""

"""

"""

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 "

"""

validate = rcsetup._validators

# validate values on the way in

def __init__(self, *args, **kwargs):

self.update(*args, **kwargs)

def _set(self, key, val):

"""

dict.__setitem__(self, key, val)

def _get(self, key):

"""

return dict.__getitem__(self, key)

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):

"""

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))

try:

import certifi

except ImportError:

_log.debug("Could not import certifi.")

return None

import ssl

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:

"""

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("""

or from the matplotlib source distribution""",

dict(key=key, fname=fname, line_no=line_no,

line=line.rstrip('\n'), version=version))

"""

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("""

""", '\n'.join(config['text.latex.preamble']))

_log.debug('loaded rc file %s', fname)

cbook._get_data_path("matplotlibrc"),

# Strip leading comment.

transform=lambda line: line[1:] if line.startswith("#") else line,

"""